@uniformdev/next-app-router 20.81.0 → 20.81.1-alpha.7.sha-91a5b13e0c

package/dist/vercel.js

@@ -0,0 +1,703 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vercel.ts
+var vercel_exports = {};
+__export(vercel_exports, {
+  expireVercelRuntimeCacheTags: () => expireVercelRuntimeCacheTags,
+  vercelManifestProvider: () => vercelManifestProvider
+});
+module.exports = __toCommonJS(vercel_exports);
+
+// src/vercel/expireVercelRuntimeCacheTags.ts
+var import_functions = require("@vercel/functions");
+
+// src/vercel/isRuntimeCacheAvailable.ts
+var isRuntimeCacheAvailable = () => process.env.NODE_ENV !== "development" || Boolean(process.env.RUNTIME_CACHE_ENDPOINT);
+
+// src/vercel/expireVercelRuntimeCacheTags.ts
+var expireVercelRuntimeCacheTags = async (tags) => {
+  if (!tags.length || !isRuntimeCacheAvailable()) {
+    return;
+  }
+  await (0, import_functions.getCache)().expireTag(tags);
+};
+
+// src/vercel/vercelManifestProvider.ts
+var import_functions2 = require("@vercel/functions");
+
+// src/clients/manifest.ts
+var import_server_only = require("server-only");
+
+// ../canvas/dist/index.mjs
+var import_api = require("@uniformdev/context/api");
+var import_api2 = require("@uniformdev/context/api");
+var import_api3 = require("@uniformdev/context/api");
+var import_api4 = require("@uniformdev/context/api");
+var import_api5 = require("@uniformdev/context/api");
+var import_api6 = require("@uniformdev/context/api");
+var import_api7 = require("@uniformdev/context/api");
+var import_api8 = require("@uniformdev/context/api");
+var import_api9 = require("@uniformdev/context/api");
+var import_api10 = require("@uniformdev/context/api");
+var import_api11 = require("@uniformdev/context/api");
+var import_api12 = require("@uniformdev/context/api");
+var import_api13 = require("@uniformdev/context/api");
+var import_api14 = require("@uniformdev/context/api");
+var import_api15 = require("@uniformdev/context/api");
+var import_api16 = require("@uniformdev/context/api");
+var import_api17 = require("@uniformdev/context/api");
+var import_api18 = require("@uniformdev/context/api");
+var import_api19 = require("@uniformdev/context/api");
+var import_api20 = require("@uniformdev/context/api");
+var import_api21 = require("@uniformdev/context/api");
+var import_api22 = require("@uniformdev/context/api");
+var import_api23 = require("@uniformdev/context/api");
+var import_api24 = require("@uniformdev/context/api");
+var import_api25 = require("@uniformdev/context/api");
+var import_api26 = require("@uniformdev/context/api");
+var import_api27 = require("@uniformdev/context/api");
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var SELECT_QUERY_PREFIX = "select.";
+function appendCsv(out, key, values) {
+  if (values === void 0) {
+    return;
+  }
+  out[key] = values.join(",");
+}
+function projectionToQuery(spec) {
+  const out = {};
+  if (!spec) {
+    return out;
+  }
+  const { fields, fieldTypes, slots } = spec;
+  const p = SELECT_QUERY_PREFIX;
+  if (fields) {
+    appendCsv(out, `${p}fields[only]`, fields.only);
+    appendCsv(out, `${p}fields[except]`, fields.except);
+    appendCsv(out, `${p}fields[locales]`, fields.locales);
+    if (fields.blockDepth === "preserveAll" || typeof fields.blockDepth === "number") {
+      out[`${p}fields[blockDepth]`] = String(fields.blockDepth);
+    }
+  }
+  if (fieldTypes) {
+    appendCsv(out, `${p}fieldTypes[only]`, fieldTypes.only);
+    appendCsv(out, `${p}fieldTypes[except]`, fieldTypes.except);
+  }
+  if (slots) {
+    appendCsv(out, `${p}slots[only]`, slots.only);
+    appendCsv(out, `${p}slots[except]`, slots.except);
+    if (typeof slots.depth === "number") {
+      out[`${p}slots[depth]`] = String(slots.depth);
+    }
+    if (slots.named) {
+      const slotNames = Object.keys(slots.named).sort();
+      for (const slotName of slotNames) {
+        const named = slots.named[slotName];
+        if (named && typeof named.depth === "number") {
+          out[`${p}slots.${slotName}[depth]`] = String(named.depth);
+        }
+      }
+    }
+  }
+  return out;
+}
+var CANVAS_DRAFT_STATE = 0;
+var CANVAS_EDITOR_STATE = 63;
+var CANVAS_INTERNAL_PARAM_PREFIX = "$internal_";
+var CANVAS_COMPONENT_DISPLAY_NAME_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}displayName`;
+var CANVAS_HYPOTHESIS_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}hypothesis`;
+var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
+var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
+var _contentTypesUrl;
+var _entriesUrl;
+var _ContentClient = class _ContentClient2 extends import_api12.ApiClient {
+  constructor(options) {
+    var _a;
+    super(options);
+    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
+  }
+  getContentTypes(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _contentTypesUrl), { ...options, projectId });
+    return this.apiClient(fetchUri);
+  }
+  getEntries(options) {
+    const { projectId } = this.options;
+    const { skipDataResolution, filters, select, ...params } = options;
+    const rewrittenFilters = (0, import_api12.rewriteFiltersForApi)(filters);
+    const rewrittenSelect = projectionToQuery(select);
+    if (skipDataResolution) {
+      const url = this.createUrl(__privateGet(_ContentClient2, _entriesUrl), {
+        ...params,
+        ...rewrittenFilters,
+        ...rewrittenSelect,
+        projectId
+      });
+      return this.apiClient(url);
+    }
+    const edgeUrl = this.createUrl(
+      __privateGet(_ContentClient2, _entriesUrl),
+      { ...this.getEdgeOptions(params), ...rewrittenFilters, ...rewrittenSelect },
+      this.edgeApiHost
+    );
+    return this.apiClient(
+      edgeUrl,
+      this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
+    );
+  }
+  /** Fetches historical versions of an entry */
+  async getEntryHistory(options) {
+    const historyUrl = this.createUrl("/api/v1/entries-history", {
+      ...options,
+      projectId: this.options.projectId
+    });
+    return this.apiClient(historyUrl);
+  }
+  async upsertContentType(body, opts = {}) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _contentTypesUrl));
+    if (typeof body.contentType.slugSettings === "object" && body.contentType.slugSettings !== null && Object.keys(body.contentType.slugSettings).length === 0) {
+      delete body.contentType.slugSettings;
+    }
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers: opts.autogenerateDataTypes ? { "x-uniform-autogenerate-data-types": "true" } : {}
+    });
+  }
+  async upsertEntry(body, options) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _entriesUrl));
+    const headers = {};
+    if (options == null ? void 0 : options.ifUnmodifiedSince) {
+      headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
+    }
+    const { response } = await this.apiClientWithResponse(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers
+    });
+    return { modified: response.headers.get("x-modified-at") };
+  }
+  async deleteContentType(body) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _contentTypesUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  async deleteEntry(body) {
+    const fetchUri = this.createUrl(__privateGet(_ContentClient2, _entriesUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  getEdgeOptions(options) {
+    const { projectId } = this.options;
+    const { skipDataResolution, ...params } = options;
+    return {
+      projectId,
+      ...params,
+      diagnostics: typeof options.diagnostics === "boolean" ? options.diagnostics : options.diagnostics === "no-data" ? "no-data" : void 0
+    };
+  }
+};
+_contentTypesUrl = /* @__PURE__ */ new WeakMap();
+_entriesUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_ContentClient, _contentTypesUrl, "/api/v1/content-types");
+__privateAdd(_ContentClient, _entriesUrl, "/api/v1/entries");
+var _url;
+var _DataTypeClient = class _DataTypeClient2 extends import_api14.ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches a list of DataTypes for a project */
+  async list(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_DataTypeClient2, _url), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
+  /** Updates or creates (based on id) a DataType */
+  async save(body) {
+    const fetchUri = this.createUrl(__privateGet(_DataTypeClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
+  /** Deletes a DataType */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_DataTypeClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url = /* @__PURE__ */ new WeakMap();
+__privateAdd(_DataTypeClient, _url, "/api/v1/data-types");
+var _baseUrl;
+var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2 extends import_api16.ApiClient {
+  constructor(options) {
+    super(options);
+    this.teamId = options.teamId;
+  }
+  /**
+   * Gets a list of property type and hook names for the current team, including public integrations' hooks.
+   */
+  get(options) {
+    const fetchUri = this.createUrl(__privateGet(_IntegrationPropertyEditorsClient2, _baseUrl), {
+      ...options,
+      teamId: this.teamId
+    });
+    return this.apiClient(fetchUri);
+  }
+  /**
+   * Creates or updates a custom AI property editor on a Mesh app.
+   */
+  async deploy(body) {
+    const fetchUri = this.createUrl(__privateGet(_IntegrationPropertyEditorsClient2, _baseUrl));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, teamId: this.teamId }),
+      expectNoContent: true
+    });
+  }
+  /**
+   * Removes a custom AI property editor from a Mesh app.
+   */
+  async delete(body) {
+    const fetchUri = this.createUrl(__privateGet(_IntegrationPropertyEditorsClient2, _baseUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, teamId: this.teamId }),
+      expectNoContent: true
+    });
+  }
+};
+_baseUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-property-editors");
+var _url2;
+var _projectsUrl;
+var _ProjectClient = class _ProjectClient2 extends import_api20.ApiClient {
+  constructor(options) {
+    super({ ...options, bypassCache: true });
+  }
+  /** Fetches single Project */
+  async get(options) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _url2), { ...options });
+    return await this.apiClient(fetchUri);
+  }
+  /**
+   * Fetches projects grouped by team.
+   * When teamId is provided, returns a single team with its projects.
+   * When omitted, returns all accessible teams and their projects.
+   */
+  async list(options) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _projectsUrl), options ? { ...options } : {});
+    return await this.apiClient(fetchUri);
+  }
+  /** @deprecated Use {@link list} instead. */
+  async getProjects(options) {
+    return this.list(options);
+  }
+  /** Updates or creates (based on id) a Project */
+  async save(body) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _url2));
+    return await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body })
+    });
+  }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
+  /** Deletes a Project */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_ProjectClient2, _url2));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link remove} instead. */
+  async delete(body) {
+    return this.remove(body);
+  }
+};
+_url2 = /* @__PURE__ */ new WeakMap();
+_projectsUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_ProjectClient, _url2, "/api/v1/project");
+__privateAdd(_ProjectClient, _projectsUrl, "/api/v1/projects");
+
+// src/clients/manifest.ts
+var import_api29 = require("@uniformdev/context/api");
+
+// src/utils/env.ts
+var env = {
+  getProjectId: () => {
+    return process.env.UNIFORM_PROJECT_ID;
+  },
+  getApiKey: () => {
+    return process.env.UNIFORM_API_KEY;
+  },
+  getApiHost: () => {
+    return process.env.UNIFORM_API_HOST || process.env.UNIFORM_CLI_BASE_URL;
+  },
+  getEdgeApiHost: () => {
+    return process.env.UNIFORM_EDGE_API_HOST || process.env.UNIFORM_CLI_BASE_EDGE_URL;
+  }
+};
+
+// src/utils/draft.ts
+var isDraftModeEnabled = ({
+  draftModeEnabled
+}) => {
+  return draftModeEnabled;
+};
+var isIncontextEditingEnabled = ({
+  isDraftModeEnabled: isDraftModeEnabled2,
+  searchParams
+}) => {
+  if (!isDraftModeEnabled2) {
+    return false;
+  }
+  const containsKey = searchParams.has(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM);
+  return containsKey;
+};
+var isDevelopmentEnvironment = () => {
+  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+};
+
+// src/clients/cache.ts
+var isSpecificCacheMode = (options) => {
+  return "cache" in options;
+};
+var isStateCacheMode = (options) => {
+  return "state" in options;
+};
+var isDetectCacheMode = (options) => {
+  return "searchParams" in options && "draftModeEnabled" in options;
+};
+var resolveManifestCache = (options) => {
+  return resolveCache({
+    options
+  });
+};
+var resolveCache = ({
+  options
+}) => {
+  let cache = void 0;
+  if (options) {
+    if (isSpecificCacheMode(options)) {
+      cache = options.cache;
+    } else if (isStateCacheMode(options)) {
+      if (options.state === CANVAS_DRAFT_STATE || options.state === CANVAS_EDITOR_STATE) {
+        cache = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    } else if (isDetectCacheMode(options)) {
+      const { disabled } = shouldCacheBeDisabled(options);
+      if (disabled) {
+        cache = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    }
+  }
+  return cache || {
+    type: "force-cache"
+  };
+};
+var shouldCacheBeDisabled = (options) => {
+  if (isDraftModeEnabled(options)) {
+    return { disabled: true, reason: "DRAFT" };
+  }
+  if (isIncontextEditingEnabled({
+    isDraftModeEnabled: options.draftModeEnabled,
+    searchParams: options.searchParams
+  })) {
+    return { disabled: true, reason: "INCONTEXT" };
+  }
+  if (isDevelopmentEnvironment()) {
+    return { disabled: true, reason: "DEV" };
+  }
+  return {
+    disabled: false,
+    reason: void 0
+  };
+};
+var determineFetchCacheOptions = (mode) => {
+  let cache = void 0;
+  let revalidate = void 0;
+  if (mode.type === "revalidate") {
+    cache = void 0;
+    revalidate = mode.interval;
+  } else {
+    cache = mode.type;
+  }
+  return {
+    cache,
+    revalidate
+  };
+};
+
+// src/clients/retry.ts
+var import_api28 = require("@uniformdev/context/api");
+function createThrottler(limit, interval) {
+  let available = limit;
+  let refillScheduled = false;
+  const waiting = [];
+  function scheduleRefill() {
+    if (refillScheduled) return;
+    refillScheduled = true;
+    setTimeout(() => {
+      refillScheduled = false;
+      available = limit;
+      while (available > 0 && waiting.length > 0) {
+        available--;
+        const next = waiting.shift();
+        next();
+      }
+      if (waiting.length > 0) {
+        scheduleRefill();
+      }
+    }, interval);
+  }
+  return async function throttle(fn) {
+    if (available > 0) {
+      available--;
+      if (!refillScheduled) {
+        scheduleRefill();
+      }
+      return fn();
+    }
+    return new Promise((resolve, reject) => {
+      waiting.push(() => {
+        fn().then(resolve, reject);
+      });
+      scheduleRefill();
+    });
+  };
+}
+function createLimiter(concurrency) {
+  let active = 0;
+  const queue = [];
+  return async function limit(fn) {
+    return new Promise((resolve, reject) => {
+      const run = async () => {
+        active++;
+        try {
+          const result = await fn();
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        } finally {
+          active--;
+          if (queue.length > 0) {
+            const next = queue.shift();
+            next();
+          }
+        }
+      };
+      if (active < concurrency) {
+        run();
+      } else {
+        queue.push(run);
+      }
+    });
+  };
+}
+async function retry(fn, options) {
+  let lastError;
+  let delay = 1e3;
+  for (let attempt = 1; attempt <= options.retries + 1; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const attemptError = Object.assign(error, { attemptNumber: attempt });
+      if (options.onFailedAttempt) {
+        await options.onFailedAttempt(attemptError);
+      }
+      if (attempt > options.retries) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay *= options.factor;
+    }
+  }
+  throw lastError;
+}
+function createLimitPolicy({
+  throttle = { interval: 1e3, limit: 10 },
+  retry: retryOptions = { retries: 1, factor: 1.66 },
+  limit = 10
+}) {
+  const throttler = throttle ? createThrottler(throttle.limit, throttle.interval) : null;
+  const limiter = limit ? createLimiter(limit) : null;
+  return function limitPolicy(func) {
+    let currentFunc = async () => await func();
+    if (throttler) {
+      const throttleFunc = currentFunc;
+      currentFunc = () => throttler(throttleFunc);
+    }
+    if (limiter) {
+      const limitFunc = currentFunc;
+      currentFunc = () => limiter(limitFunc);
+    }
+    if (retryOptions) {
+      const retryFunc = currentFunc;
+      currentFunc = () => retry(retryFunc, {
+        ...retryOptions,
+        onFailedAttempt: async (error) => {
+          if (retryOptions.onFailedAttempt) {
+            await retryOptions.onFailedAttempt(error);
+          }
+          if (error instanceof import_api28.ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
+            throw error;
+          }
+        }
+      });
+    }
+    return currentFunc();
+  };
+}
+
+// src/clients/tags.ts
+var generateManifestCacheTags = () => {
+  return ["manifest"];
+};
+
+// src/clients/manifest.ts
+var getManifestClient = (options) => {
+  const cache = resolveManifestCache(options);
+  const manifestClient = new import_api29.ManifestClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    limitPolicy: createLimitPolicy({
+      limit: 6
+    }),
+    fetch: (req, init) => {
+      const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache.bypassCache !== "undefined" ? cache.bypassCache.toString() : "false"
+        },
+        cache: fetchCache,
+        next: {
+          revalidate,
+          tags: generateManifestCacheTags()
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+
+// src/manifest/createCachedManifestProvider.ts
+var createCachedManifestProvider = ({
+  cache,
+  fallback,
+  ttl = 3600,
+  maxAge = 10,
+  fetchManifest = fetchPublishedManifest
+} = {}) => {
+  let current;
+  let pending;
+  const load = async ({ waitUntil }) => {
+    var _a;
+    const key = `uniform-manifest-${(_a = env.getProjectId()) != null ? _a : ""}`;
+    const cached = await (cache == null ? void 0 : cache.get(key).catch(() => void 0));
+    if (isManifest(cached)) {
+      return cached;
+    }
+    const manifest = await fetchManifest();
+    if (cache) {
+      waitUntil(cache.set(key, manifest, { ttl, tags: generateManifestCacheTags() }).catch(() => {
+      }));
+    }
+    return manifest;
+  };
+  return async (options) => {
+    var _a;
+    if (current && Date.now() - current.loadedAt < maxAge * 1e3) {
+      return current.manifest;
+    }
+    pending != null ? pending : pending = load(options).then((manifest) => {
+      current = { manifest, loadedAt: Date.now() };
+      return manifest;
+    }).finally(() => {
+      pending = void 0;
+    });
+    try {
+      return await pending;
+    } catch (error) {
+      const known = (_a = current == null ? void 0 : current.manifest) != null ? _a : fallback;
+      if (known) {
+        return known;
+      }
+      throw error;
+    }
+  };
+};
+var fetchPublishedManifest = () => getManifestClient({ cache: { type: "no-store" } }).get({ preview: false });
+var isManifest = (value) => typeof value === "object" && value !== null && "project" in value;
+
+// src/vercel/vercelManifestProvider.ts
+var runtimeCache = {
+  get: (key) => (0, import_functions2.getCache)().get(key),
+  set: (key, value, options) => (0, import_functions2.getCache)().set(key, value, options)
+};
+var vercelManifestProvider = (options = {}) => createCachedManifestProvider({
+  ...options,
+  cache: isRuntimeCacheAvailable() ? runtimeCache : void 0
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expireVercelRuntimeCacheTags,
+  vercelManifestProvider
+});