@flamingo-stack/openframe-frontend-core 0.0.719 → 0.0.721

package/src/contexts/assistant-runtime-context.tsx

@@ -0,0 +1,84 @@
+'use client';
+
+/**
+ * Assistant runtime context: what a PAGE needs to offer the host's chat
+ * assistant ("Ask Mingo"): whether a chat is there to open, the assistant's
+ * name and glyph, where its questions are read from, and HOW the chat is
+ * opened and asked.
+ *
+ * A sibling of `ChatRuntimeContext` (which configures the chat panel itself)
+ * and `EndpointsRuntimeContext`. It is its own context because its values
+ * change with the visitor (signed in or not, chat mounted or not), and a new
+ * `ChatRuntime` identity re-renders the whole chat tree.
+ *
+ * The NEAREST provider wins, so a page region that carries its own chat (an
+ * embedded chat beside the content) mounts a provider whose `open` opens THAT
+ * chat: every "ask" surface under it (`FaqSection`'s card, `AskPrompts`,
+ * `AskCard`) then opens and fills it, with no prop on any of them.
+ *
+ * No provider, or `available: false`: the "ask" surfaces render nothing.
+ */
+
+import { createContext, useContext, type ReactNode } from 'react';
+
+/** What an "ask" surface asks the chat to do. */
+export interface AssistantOpenRequest {
+  /** A question to send once the chat is open. Absent: the chat only opens. */
+  prompt?: string;
+  /** The topic of the surface that asked (a FAQ's topic, a page section). */
+  topic?: string;
+}
+
+/** What an "ask" surface reports after a question was sent (analytics). */
+export interface AssistantAskEvent {
+  /** The id of the question that was asked. */
+  promptId: string;
+  /** The topic of the surface that asked. */
+  topic?: string;
+}
+
+/** The wording of the card beside a FAQ. `{assistant}` is replaced by the assistant's name. */
+export interface AssistantAskCardCopy {
+  title?: string;
+  description?: string;
+  /** How many questions the card offers. */
+  count?: number;
+}
+
+export interface AssistantRuntime {
+  /** A chat is mounted for this visitor: an "ask" click has something to open. */
+  available: boolean;
+  /** The assistant's configured name. */
+  name?: string | null;
+  /** The assistant's configured glyph. Absent: the packaged Mingo mark. */
+  icon?: ReactNode;
+  /** The chat source the default `open` addresses its `ask-ai:open` event to. */
+  source?: string;
+  /**
+   * GET endpoint the questions are read from:
+   *   `<url>?count=<n>&section=<topic>&exclude=<id,id>` → `{ prompts: AskPrompt[] }`
+   * `section` is ANY string: the host decides what topics exist (the hub: the
+   * `section` attribute of a quick action, set in chat config), so a new topic
+   * needs no change here. Hub: '/api/quick-actions/questions'. Absent: an "ask"
+   * surface shows its launcher with no questions.
+   */
+  askPromptsUrl?: string;
+  /**
+   * Open the chat and, with `prompt`, ask it. Absent: the `ask-ai:open` event
+   * of `source` (`openAskAi`), which the mounted `EmbeddableChat` listens for.
+   * A host whose chat is opened another way (an embedded chat, a different
+   * panel) supplies its own.
+   */
+  open?: (request: AssistantOpenRequest) => void;
+  /** After a question was sent (analytics). */
+  onAsk?: (event: AssistantAskEvent) => void;
+  /** The wording of the card beside a FAQ. Absent: the lib's own. */
+  askCard?: AssistantAskCardCopy;
+}
+
+export const AssistantRuntimeContext = createContext<AssistantRuntime | null>(null);
+
+/** The nearest assistant runtime, or null when no provider is mounted. */
+export function useAssistantRuntime(): AssistantRuntime | null {
+  return useContext(AssistantRuntimeContext);
+}

package/src/contexts/index.ts

@@ -30,4 +30,13 @@ export {
 
 export { ChatRuntimeContext, useChatRuntime, useRequiredChatRuntime, type ChatRuntime } from './chat-runtime-context';
 
+export {
+  AssistantRuntimeContext,
+  useAssistantRuntime,
+  type AssistantAskCardCopy,
+  type AssistantAskEvent,
+  type AssistantOpenRequest,
+  type AssistantRuntime,
+} from './assistant-runtime-context';
+
 export { useOuterOrDefault } from './use-outer-or-default';

package/src/hooks/index.ts

@@ -4,6 +4,7 @@ export * from './platform';
 export * from './use-toast';
 export * from './use-contact-submission';
 export * from './use-copy-to-clipboard';
+export * from './use-downloads';
 
 // Image authentication hooks
 export * from './use-batch-images';

package/src/hooks/use-downloads.ts

@@ -0,0 +1,138 @@
+'use client';
+
+import { useCallback, useEffect, useSyncExternalStore } from 'react';
+import { DOWNLOADS_API_PATH, type AppDownload, type DownloadsPublic } from '../types/downloads';
+import { contentFetch } from '../utils/embed-content-fetch';
+import { desktopOsOf } from '../utils/visitor-os';
+import { useVisitorOs } from './ui/use-visitor-os';
+
+export interface DownloadsState {
+  /** The server's answer; null until it lands. */
+  data: DownloadsPublic | null;
+  isLoading: boolean;
+  error: boolean;
+}
+
+interface Entry {
+  state: DownloadsState;
+  request: Promise<void> | null;
+  listeners: Set<() => void>;
+}
+
+const IDLE: DownloadsState = { data: null, isLoading: false, error: false };
+
+/**
+ * One entry per endpoint for the life of the page. Every download button on a
+ * page asks the same question, so they share ONE request and one answer: the
+ * list changes only when the server is redeployed, never while a page is open.
+ */
+const entries = new Map<string, Entry>();
+
+function entryFor(endpoint: string): Entry {
+  let entry = entries.get(endpoint);
+  if (!entry) {
+    entry = { state: IDLE, request: null, listeners: new Set() };
+    entries.set(endpoint, entry);
+  }
+  return entry;
+}
+
+function publish(endpoint: string, state: DownloadsState) {
+  const entry = entryFor(endpoint);
+  entry.state = state;
+  for (const listener of entry.listeners) listener();
+}
+
+function load(endpoint: string, force = false): void {
+  const entry = entryFor(endpoint);
+  if (entry.request || (entry.state.data && !force)) return;
+  publish(endpoint, { data: entry.state.data, isLoading: true, error: false });
+  entry.request = contentFetch(endpoint)
+    .then(async response => {
+      if (!response.ok) throw new Error(`Request failed (${response.status})`);
+      publish(endpoint, { data: (await response.json()) as DownloadsPublic, isLoading: false, error: false });
+    })
+    .catch(() => publish(endpoint, { data: entry.state.data, isLoading: false, error: true }))
+    .finally(() => {
+      entry.request = null;
+    });
+}
+
+/** Test seam: forget every answer. */
+export function resetDownloadsStore(): void {
+  entries.clear();
+}
+
+export interface UseDownloadsOptions {
+  /** GET endpoint for the public projection. Default `DOWNLOADS_API_PATH`; embedders pass their proxy path. */
+  endpoint?: string;
+  /** The server's copy (a host that read it during SSR): no request is made. */
+  initialData?: DownloadsPublic;
+  /** False: nothing is requested (a host that does not offer the desktop app). Default true. */
+  enabled?: boolean;
+}
+
+/**
+ * What the OpenFrame desktop app is installed from, read FROM THE SERVER
+ * (`GET /api/downloads`). The links and package names live in the server's
+ * environment; no client holds a copy of its own. Every caller on a page shares
+ * one request.
+ */
+export function useDownloads({ endpoint = DOWNLOADS_API_PATH, initialData, enabled = true }: UseDownloadsOptions = {}) {
+  const entry = entryFor(endpoint);
+  // A server copy is the answer: held from the first render (server and client alike), and never re-requested.
+  // Written during render so THIS caller's first paint has it; a render cannot notify other callers.
+  if (initialData && entry.state.data !== initialData && !entry.request) {
+    entry.state = { data: initialData, isLoading: false, error: false };
+  }
+  // So the callers that rendered before this one (a header button above the page) are told after
+  // the commit: they re-read the shared answer instead of staying on the empty one they first saw.
+  useEffect(() => {
+    if (!initialData) return;
+    for (const listener of entry.listeners) listener();
+  }, [entry, initialData]);
+  const subscribe = useCallback(
+    (listener: () => void) => {
+      entry.listeners.add(listener);
+      return () => {
+        entry.listeners.delete(listener);
+      };
+    },
+    [entry],
+  );
+  const state = useSyncExternalStore(
+    subscribe,
+    () => entry.state,
+    () => entry.state,
+  );
+
+  useEffect(() => {
+    if (enabled) load(endpoint);
+  }, [enabled, endpoint]);
+
+  const reload = useCallback(() => load(endpoint, true), [endpoint]);
+  // Until the effect has asked, an enabled caller with no answer is loading, not empty.
+  const isLoading = state.isLoading || (enabled && !state.data && !state.error);
+  return { data: state.data, isLoading, error: state.error, reload };
+}
+
+export interface VisitorDesktopDownload {
+  /** False until the visitor's system AND the server's list are both known. */
+  known: boolean;
+  /** This visitor's installer (the first one for their system); null when nothing installs on it. */
+  download: AppDownload | null;
+}
+
+/**
+ * The installer a download button offers THIS visitor: the server's first
+ * installer for the system they are on. `enabled: false` asks for nothing.
+ */
+export function useVisitorDesktopDownload(options: UseDownloadsOptions = {}): VisitorDesktopDownload {
+  const enabled = options.enabled ?? true;
+  const visitor = useVisitorOs();
+  const { data, error } = useDownloads(options);
+  if (!enabled || !visitor.known || (!data && !error)) return { known: false, download: null };
+  const os = desktopOsOf(visitor.os);
+  const download = data?.desktop.find(row => row.kind === 'binary' && row.url && row.os === os) ?? null;
+  return { known: true, download };
+}

package/src/types/downloads.ts

@@ -0,0 +1,82 @@
+/**
+ * The download page's wire shape and vocabulary: what the OpenFrame apps are
+ * installed from. The hub answers `DOWNLOADS_API_PATH` with `DownloadsPublic`;
+ * the lib's `<DownloadAppsPage>` renders it (hub SSR, openframe-frontend through
+ * its `/content` proxy, the embedding example).
+ */
+import type { DesktopOs } from '../utils/visitor-os';
+
+/** GET endpoint for the public downloads projection (the hub's path; embedders prefix their proxy). */
+export const DOWNLOADS_API_PATH = '/api/downloads';
+
+/** How long a copy stays fresh: the CDN window of the route, and the page's revalidation age. */
+export const DOWNLOADS_CACHE_SECONDS = 300;
+
+export const DOWNLOADS_TITLE = 'Download OpenFrame';
+export const DOWNLOADS_TAGLINE =
+  'Install it on the computer you manage IT from, and on your phone. One account everywhere.';
+/** The title and subtitle when a host offers the mobile app only. */
+export const DOWNLOADS_MOBILE_TITLE = 'Get the OpenFrame app';
+export const DOWNLOADS_MOBILE_TAGLINE =
+  'Alerts and tickets on your phone, signed in with the account you already have.';
+
+/**
+ * What a row is: an installer file, or a one-line package manager install. THE
+ * one declaration: the type, the server's rows and every reader derive from it.
+ */
+export const APP_DOWNLOAD_KINDS = ['binary', 'command'] as const;
+export type AppDownloadKind = (typeof APP_DOWNLOAD_KINDS)[number];
+
+/** One way to install the desktop app on one system. */
+export interface AppDownload {
+  id: string;
+  kind: AppDownloadKind;
+  os: DesktopOs;
+  /** `universal`, `x64`, `arm64`; null for a command. */
+  architecture: string | null;
+  /** The installer's address (`binary`). */
+  url: string | null;
+  /** The whole command to paste (`command`). */
+  command: string | null;
+  /** "macOS 13+". */
+  minOsLabel: string | null;
+  /** The package manager's name (`command`), or the button's own words (`binary`). */
+  label: string | null;
+}
+
+/** Where the mobile app is installed from. A store the server names no listing for is null, and is not offered. */
+export interface MobileAppLinks {
+  appStoreUrl: string | null;
+  googlePlayUrl: string | null;
+}
+
+/**
+ * Everything the download page shows. All of it is the server's: the lib holds
+ * no link of its own and falls back to none, so what is missing is not drawn.
+ */
+export interface DownloadsPublic {
+  /** The desktop installers and install commands, in the order they are offered. Per system, the first installer is the default. */
+  desktop: AppDownload[];
+  /** The mobile app's store listings. */
+  mobile: MobileAppLinks;
+}
+
+/** A system's name on a button and a card. */
+export const DESKTOP_OS_LABELS: Record<DesktopOs, string> = { mac: 'Mac', windows: 'Windows', linux: 'Linux' };
+
+/** An architecture's name beside a button, when a system has more than one installer. */
+export const DOWNLOAD_ARCHITECTURE_LABELS: Record<string, string> = {
+  universal: 'Apple Silicon and Intel',
+  x64: 'x64',
+  arm64: 'ARM',
+};
+
+/** What a host learns when a visitor takes an install action on the page. */
+export interface DownloadActionEvent {
+  /** `installer`: a download button. `command`: a copied install command. */
+  action: 'installer' | 'command';
+  /** The row's id (`mac`, `windows-arm64`, `homebrew`). */
+  id: string;
+  os: DesktopOs;
+  architecture: string | null;
+}

package/src/types/index.ts

@@ -55,6 +55,7 @@ export * from './waitlist';
 // Business logic types
 export * from './faq';
 export * from './trust-center';
+export * from './downloads';
 export * from './content-ref';
 export * from './report';
 export * from './stack';

package/src/utils/index.ts

@@ -17,6 +17,7 @@ export {
 // source of truth). Re-exported here so existing callers that pull from
 // the barrel keep working without changing imports.
 export { formatDate, formatNumber, formatPrice, formatBytes } from './format';
+export { TRIAL_DAYS, TRIAL_LABELS } from './trial';
 export {
   VENDOR_CLASSIFICATIONS,
   OPENFRAME_CLASSIFICATIONS,
@@ -117,6 +118,8 @@ export * from './video-bite-id';
 // OS type utilities
 export * from './os-utils';
 export * from './visitor-os';
+// Also exported via the granular subpath `./utils/mobile-app` (server and Edge consumers).
+export * from './mobile-app';
 // Phone utilities
 export * from './country-phone-utils';
 export * from './compliance-standards';

package/src/utils/list-url.ts

@@ -116,6 +116,10 @@ const BUILDERS: Record<string, (ids: string[], base: string) => string> = {
   design_doc: (ids, b) => `${b}/api/design-docs?ids=${ids.join(',')}`,
   openframe_tenant: (ids, b) => `${b}/api/openframe-tenants?ids=${ids.join(',')}`,
   prospect_call: (ids, b) => `${b}/api/prospect-calls?ids=${ids.join(',')}`,
+  // The public website's own pages (live source; ChatRef-shaped items like the objects above).
+  site_page: (ids, b) => `${b}/api/site-pages?ids=${ids.join(',')}`,
+  // The OpenMSP vendor directory (indexed source).
+  vendor: (ids, b) => `${b}/api/vendors/cards?ids=${ids.join(',')}`,
   // Code intelligence — per-object card hydration, same `handleEntityCardList`
   // shape as the internal objects above.
   code_rule: (ids, b) => `${b}/api/code-rules/cards?ids=${ids.join(',')}`,

package/src/utils/mobile-app.ts

@@ -0,0 +1,57 @@
+/**
+ * The download page's own addresses: where it lives, the parameter that sends a
+ * phone on to its store, and the URL the install QR code encodes. The store
+ * listings and installer links are NOT here: they are the server's
+ * (`DownloadsPublic`, read through `useDownloads`).
+ *
+ * Pure and server-safe; also published as the granular subpath
+ * `./utils/mobile-app`, for an Edge proxy and other server-only consumers.
+ */
+import type { MobileAppLinks } from '../types/downloads';
+import { detectVisitorOs } from './visitor-os';
+
+/** The website's download page: every installer and the mobile app. */
+export const DOWNLOAD_PAGE_PATH = '/download';
+
+/**
+ * On the download page: "send a phone or a tablet on to its store". The install
+ * QR code carries it, because whoever scans a code is holding the phone the app
+ * goes on. Anyone who opens the page without it reads the page.
+ */
+export const DOWNLOAD_PAGE_STORE_PARAM = 'store';
+
+/**
+ * The one URL the install QR code encodes: the website's download page, asking
+ * it to send a phone on to its store.
+ *
+ * Absolute and on the production host on purpose: a code must point at
+ * production whichever deployment rendered the page it came from. `MobileAppQr`
+ * draws this value as committed path data, so the two change together: see the
+ * regeneration note on that component.
+ */
+export const MOBILE_APP_INSTALL_URL = `https://www.flamingo.run${DOWNLOAD_PAGE_PATH}?${DOWNLOAD_PAGE_STORE_PARAM}=1`;
+
+/** The download page as it is printed for a human to read or type: no scheme, no `www`, no query. */
+export const MOBILE_APP_INSTALL_HOST_PATH = MOBILE_APP_INSTALL_URL.replace(/^https:\/\/(www\.)?/, '').replace(
+  /\?.*$/,
+  '',
+);
+
+/**
+ * The store for a phone or tablet, or `null` for every other system and for a
+ * store the server names no listing for (`links` is the server's answer).
+ *
+ * The server passes the request's User-Agent; a browser also passes
+ * `navigator.maxTouchPoints`, the only signal that tells an iPad asking for the
+ * desktop site (it calls itself a Macintosh) from a real Mac.
+ */
+export function resolveMobileStoreUrl(
+  links: MobileAppLinks,
+  userAgent: string | null | undefined,
+  maxTouchPoints?: number,
+): string | null {
+  const os = detectVisitorOs(userAgent, { maxTouchPoints });
+  if (os === 'ios') return links.appStoreUrl;
+  if (os === 'android') return links.googlePlayUrl;
+  return null;
+}

package/src/utils/source-icons.ts

@@ -54,8 +54,12 @@ export const SOURCE_ICON_NAMES: Record<string, string> = {
   'audience-mssp': 'shield-lock',
   'audience-it-team': 'buildings',
 
-  // Trust (single-record live source over the public Vanta projection)
-  'trust-center': 'shield',
+  // Trust (single-record live source over the public Vanta projection): the icon its menu entry draws
+  'trust-center': 'shield-check',
+  // The public website's own pages (live source): the site's own mark, as a glyph in the slot's colour
+  'website-pages': 'flamingo-logo-grey',
+  // The OpenMSP vendor directory: the icon the site menu's "Tool directory" entry draws (it reads this one)
+  vendors: 'package-search',
 
   // Financials
   'investor-updates': 'mail',
@@ -145,6 +149,8 @@ export const SOURCE_LABELS_BY_TABLE: Record<string, string> = {
 
   // Trust
   'trust-center': 'Trust Center',
+  'website-pages': 'Website',
+  vendors: 'Vendor Directory',
 
   // Financials
   'investor-updates': 'Investor Updates',
@@ -248,6 +254,8 @@ export const DEFAULT_DOCUMENT_TYPE_TO_TABLE_ID: Record<string, string> = {
 
   // Trust
   trust_center: 'trust-center',
+  site_page: 'website-pages',
+  vendor: 'vendors',
 
   // Financials
   investor_update: 'investor-updates',

package/src/utils/trial.ts

@@ -0,0 +1,19 @@
+/**
+ * The free trial's facts and the words every surface says them with: the
+ * sign-up panel here, and the host site's trial buttons, trust rows and pricing
+ * copy. Stated once, so a trial that changes length changes everywhere.
+ *
+ * Server-safe (no React, no DOM).
+ */
+
+/** How long the free trial runs, in days. */
+export const TRIAL_DAYS = 14;
+
+/** The reassurance labels shown beside a trial button. */
+export const TRIAL_LABELS = {
+  /** "14 day free trial" */
+  length: `${TRIAL_DAYS} day free trial`,
+  noCard: 'No card required',
+  cancel: 'Cancel Anytime',
+  noContract: 'No Contract',
+} as const;

package/dist/chunk-6X3O67OL.cjs

@@ -1,89 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
-
-
-var _chunkAUMKE74Mcjs = require('./chunk-AUMKE74M.cjs');
-
-// src/hooks/use-self-fetch.ts
-var _react = require('react');
-function useSelfFetch(url, options) {
-  const initialData = _optionalChain([options, 'optionalAccess', _ => _.initialData]);
-  const revalidateOnVisibleAfterMs = _optionalChain([options, 'optionalAccess', _2 => _2.revalidateOnVisibleAfterMs]);
-  const [data, setData] = _react.useState.call(void 0, _nullishCoalesce(initialData, () => ( null)));
-  const [dataUrl, setDataUrl] = _react.useState.call(void 0, initialData !== void 0 ? url : null);
-  const [isLoading, setIsLoading] = _react.useState.call(void 0, initialData === void 0 && url !== null);
-  const [error, setError] = _react.useState.call(void 0, false);
-  const [reloadKey, setReloadKey] = _react.useState.call(void 0, 0);
-  const [mountedAt] = _react.useState.call(void 0, () => Date.now());
-  const dataAtRef = _react.useRef.call(void 0, initialData !== void 0 ? mountedAt : 0);
-  const dataUrlRef = _react.useRef.call(void 0, initialData !== void 0 ? url : null);
-  const [syncedProps, setSyncedProps] = _react.useState.call(void 0, { url, initialData });
-  if (syncedProps.url !== url || syncedProps.initialData !== initialData) {
-    setSyncedProps({ url, initialData });
-    if (syncedProps.initialData !== initialData && initialData !== void 0) {
-      setData(initialData);
-      setDataUrl(url);
-    }
-    if (syncedProps.url !== url && url === null) {
-      setIsLoading(false);
-    }
-  }
-  _react.useEffect.call(void 0, () => {
-    if (url === null) return void 0;
-    if (dataUrlRef.current === url) return void 0;
-    const ctrl = new AbortController();
-    let cancelled = false;
-    async function load() {
-      try {
-        setIsLoading(true);
-        setError(false);
-        const res = await _chunkAUMKE74Mcjs.contentFetch.call(void 0, url, { signal: ctrl.signal });
-        if (!res.ok) throw new Error(`Request failed (${res.status})`);
-        const json = await res.json();
-        if (!cancelled) {
-          setData(json);
-          setDataUrl(url);
-          dataUrlRef.current = url;
-          dataAtRef.current = Date.now();
-        }
-      } catch (err) {
-        if (cancelled || _optionalChain([err, 'optionalAccess', _3 => _3.name]) === "AbortError") return;
-        setError(true);
-        console.error("useSelfFetch:", url, err);
-      } finally {
-        if (!cancelled) setIsLoading(false);
-      }
-    }
-    void load();
-    return () => {
-      cancelled = true;
-      ctrl.abort();
-    };
-  }, [url, reloadKey]);
-  const forceReload = () => {
-    dataUrlRef.current = null;
-    setReloadKey((k) => k + 1);
-  };
-  _react.useEffect.call(void 0, () => {
-    if (!revalidateOnVisibleAfterMs || url === null) return void 0;
-    const onVisible = () => {
-      if (document.visibilityState !== "visible") return;
-      if (Date.now() - dataAtRef.current < revalidateOnVisibleAfterMs) return;
-      forceReload();
-    };
-    document.addEventListener("visibilitychange", onVisible);
-    return () => document.removeEventListener("visibilitychange", onVisible);
-  }, [url, revalidateOnVisibleAfterMs]);
-  return {
-    data,
-    dataUrl,
-    setData,
-    isLoading,
-    error,
-    // Force a re-fetch of the current url (error-retry affordance).
-    reload: forceReload
-  };
-}
-
-
-
-exports.useSelfFetch = useSelfFetch;

package/dist/chunk-AUMKE74M.cjs

@@ -1,16 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
-
-
-
-var _chunkULWVKHSIcjs = require('./chunk-ULWVKHSI.cjs');
-
-// src/utils/embed-content-fetch.ts
-var contentFetch = (input, init) => {
-  if (!_chunkULWVKHSIcjs.hasEmbedAuthAdapter.call(void 0, )) return fetch(input, init);
-  const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-  return _chunkULWVKHSIcjs.embedAuthedFetch.call(void 0, url, init);
-};
-
-
-
-exports.contentFetch = contentFetch;

package/dist/chunk-G3GRYDMS.js

@@ -1,16 +0,0 @@
-"use client";
-import {
-  embedAuthedFetch,
-  hasEmbedAuthAdapter
-} from "./chunk-ADBE7QF3.js";
-
-// src/utils/embed-content-fetch.ts
-var contentFetch = (input, init) => {
-  if (!hasEmbedAuthAdapter()) return fetch(input, init);
-  const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-  return embedAuthedFetch(url, init);
-};
-
-export {
-  contentFetch
-};