@farcaster/frame-host 0.0.21 → 0.0.22

package/dist/comlink/comlink.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Endpoint, EventSource, PostMessageWithOrigin } from "./protocol";
+import { type Endpoint, type EventSource, type PostMessageWithOrigin } from './protocol';
 export type { Endpoint };
 export declare const proxyMarker: unique symbol;
 export declare const createEndpoint: unique symbol;

package/dist/comlink/comlink.js

@@ -3,12 +3,13 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export const proxyMarker = Symbol("Comlink.proxy");
-export const createEndpoint = Symbol("Comlink.endpoint");
-export const releaseProxy = Symbol("Comlink.releaseProxy");
-export const finalizer = Symbol("Comlink.finalizer");
-const throwMarker = Symbol("Comlink.thrown");
-const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+import { MessageType, WireValueType, } from './protocol';
+export const proxyMarker = Symbol('Comlink.proxy');
+export const createEndpoint = Symbol('Comlink.endpoint');
+export const releaseProxy = Symbol('Comlink.releaseProxy');
+export const finalizer = Symbol('Comlink.finalizer');
+const throwMarker = Symbol('Comlink.thrown');
+const isObject = (val) => (typeof val === 'object' && val !== null) || typeof val === 'function';
 /**
  * Internal transfer handle to handle objects marked to proxy.
  */
@@ -57,12 +58,12 @@ const throwTransferHandler = {
  * Allows customizing the serialization of certain values.
  */
 export const transferHandlers = new Map([
-    ["proxy", proxyTransferHandler],
-    ["throw", throwTransferHandler],
+    ['proxy', proxyTransferHandler],
+    ['throw', throwTransferHandler],
 ]);
 function isAllowedOrigin(allowedOrigins, origin) {
     for (const allowedOrigin of allowedOrigins) {
-        if (origin === allowedOrigin || allowedOrigin === "*") {
+        if (origin === allowedOrigin || allowedOrigin === '*') {
             return true;
         }
         if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
@@ -71,7 +72,7 @@ function isAllowedOrigin(allowedOrigins, origin) {
     }
     return false;
 }
-export function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+export function expose(obj, ep = globalThis, allowedOrigins = ['*']) {
     function callback(ev) {
         if (!ev || !ev.data) {
             return;
@@ -90,36 +91,36 @@ export function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
             const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
             const rawValue = path.reduce((obj, prop) => obj[prop], obj);
             switch (type) {
-                case "GET" /* MessageType.GET */:
+                case MessageType.GET:
                     {
                         returnValue = rawValue;
                     }
                     break;
-                case "SET" /* MessageType.SET */:
+                case MessageType.SET:
                     {
                         parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
                         returnValue = true;
                     }
                     break;
-                case "APPLY" /* MessageType.APPLY */:
+                case MessageType.APPLY:
                     {
                         returnValue = rawValue.apply(parent, argumentList);
                     }
                     break;
-                case "CONSTRUCT" /* MessageType.CONSTRUCT */:
+                case MessageType.CONSTRUCT:
                     {
                         const value = new rawValue(...argumentList);
                         returnValue = proxy(value);
                     }
                     break;
-                case "ENDPOINT" /* MessageType.ENDPOINT */:
+                case MessageType.ENDPOINT:
                     {
                         const { port1, port2 } = new MessageChannel();
                         expose(obj, port2);
                         returnValue = transfer(port1, [port1]);
                     }
                     break;
-                case "RELEASE" /* MessageType.RELEASE */:
+                case MessageType.RELEASE:
                     {
                         returnValue = undefined;
                     }
@@ -138,11 +139,11 @@ export function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
             .then((returnValue) => {
             const [wireValue, transferables] = toWireValue(returnValue);
             ep.postMessage({ ...wireValue, id }, transferables);
-            if (type === "RELEASE" /* MessageType.RELEASE */) {
+            if (type === MessageType.RELEASE) {
                 // detach and deactive after sending release response above.
-                ep.removeEventListener("message", callback);
+                ep.removeEventListener('message', callback);
                 closeEndPoint(ep);
-                if (finalizer in obj && typeof obj[finalizer] === "function") {
+                if (finalizer in obj && typeof obj[finalizer] === 'function') {
                     obj[finalizer]();
                 }
             }
@@ -150,26 +151,26 @@ export function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
             .catch((error) => {
             // Send Serialization Error To Caller
             const [wireValue, transferables] = toWireValue({
-                value: new TypeError("Unserializable return value"),
+                value: new TypeError('Unserializable return value'),
                 [throwMarker]: 0,
             });
             ep.postMessage({ ...wireValue, id }, transferables);
         });
     }
-    ep.addEventListener("message", callback);
+    ep.addEventListener('message', callback);
     if (ep.start) {
         ep.start();
     }
     return () => {
-        ep.removeEventListener("message", callback);
+        ep.removeEventListener('message', callback);
         closeEndPoint(ep);
-        if (finalizer in obj && typeof obj[finalizer] === "function") {
+        if (finalizer in obj && typeof obj[finalizer] === 'function') {
             obj[finalizer]();
         }
     };
 }
 function isMessagePort(endpoint) {
-    return endpoint.constructor.name === "MessagePort";
+    return endpoint.constructor.name === 'MessagePort';
 }
 function closeEndPoint(endpoint) {
     if (isMessagePort(endpoint))
@@ -177,7 +178,7 @@ function closeEndPoint(endpoint) {
 }
 export function wrap(ep, target) {
     const pendingListeners = new Map();
-    ep.addEventListener("message", function handleMessage(ev) {
+    ep.addEventListener('message', function handleMessage(ev) {
         const { data } = ev;
         if (!data || !data.id) {
             return;
@@ -197,18 +198,18 @@ export function wrap(ep, target) {
 }
 function throwIfProxyReleased(isReleased) {
     if (isReleased) {
-        throw new Error("Proxy has been released and is not useable");
+        throw new Error('Proxy has been released and is not useable');
     }
 }
 function releaseEndpoint(ep) {
     return requestResponseMessage(ep, new Map(), {
-        type: "RELEASE" /* MessageType.RELEASE */,
+        type: MessageType.RELEASE,
     }).then(() => {
         closeEndPoint(ep);
     });
 }
 const proxyCounter = new WeakMap();
-const proxyFinalizers = "FinalizationRegistry" in globalThis &&
+const proxyFinalizers = 'FinalizationRegistry' in globalThis &&
     new FinalizationRegistry((ep) => {
         const newCount = (proxyCounter.get(ep) || 0) - 1;
         proxyCounter.set(ep, newCount);
@@ -228,7 +229,7 @@ function unregisterProxy(proxy) {
         proxyFinalizers.unregister(proxy);
     }
 }
-function createProxy(ep, pendingListeners, path = [], target = function () { }) {
+function createProxy(ep, pendingListeners, path = [], target = () => { }) {
     let isProxyReleased = false;
     const proxy = new Proxy(target, {
         get(_target, prop) {
@@ -241,12 +242,12 @@ function createProxy(ep, pendingListeners, path = [], target = function () { })
                     isProxyReleased = true;
                 };
             }
-            if (prop === "then") {
+            if (prop === 'then') {
                 if (path.length === 0) {
                     return { then: () => proxy };
                 }
                 const r = requestResponseMessage(ep, pendingListeners, {
-                    type: "GET" /* MessageType.GET */,
+                    type: MessageType.GET,
                     path: path.map((p) => p.toString()),
                 }).then(fromWireValue);
                 return r.then.bind(r);
@@ -259,7 +260,7 @@ function createProxy(ep, pendingListeners, path = [], target = function () { })
             // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
             const [value, transferables] = toWireValue(rawValue);
             return requestResponseMessage(ep, pendingListeners, {
-                type: "SET" /* MessageType.SET */,
+                type: MessageType.SET,
                 path: [...path, prop].map((p) => p.toString()),
                 value,
             }, transferables).then(fromWireValue);
@@ -269,16 +270,16 @@ function createProxy(ep, pendingListeners, path = [], target = function () { })
             const last = path[path.length - 1];
             if (last === createEndpoint) {
                 return requestResponseMessage(ep, pendingListeners, {
-                    type: "ENDPOINT" /* MessageType.ENDPOINT */,
+                    type: MessageType.ENDPOINT,
                 }).then(fromWireValue);
             }
             // We just pretend that `bind()` didn’t happen.
-            if (last === "bind") {
+            if (last === 'bind') {
                 return createProxy(ep, pendingListeners, path.slice(0, -1));
             }
             const [argumentList, transferables] = processArguments(rawArgumentList);
             return requestResponseMessage(ep, pendingListeners, {
-                type: "APPLY" /* MessageType.APPLY */,
+                type: MessageType.APPLY,
                 path: path.map((p) => p.toString()),
                 argumentList,
             }, transferables).then(fromWireValue);
@@ -287,7 +288,7 @@ function createProxy(ep, pendingListeners, path = [], target = function () { })
             throwIfProxyReleased(isProxyReleased);
             const [argumentList, transferables] = processArguments(rawArgumentList);
             return requestResponseMessage(ep, pendingListeners, {
-                type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
+                type: MessageType.CONSTRUCT,
                 path: path.map((p) => p.toString()),
                 argumentList,
             }, transferables).then(fromWireValue);
@@ -311,7 +312,7 @@ export function transfer(obj, transfers) {
 export function proxy(obj) {
     return Object.assign(obj, { [proxyMarker]: true });
 }
-export function windowEndpoint(w, context = globalThis, targetOrigin = "*") {
+export function windowEndpoint(w, context = globalThis, targetOrigin = '*') {
     return {
         postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),
         addEventListener: context.addEventListener.bind(context),
@@ -324,7 +325,7 @@ function toWireValue(value) {
             const [serializedValue, transferables] = handler.serialize(value);
             return [
                 {
-                    type: "HANDLER" /* WireValueType.HANDLER */,
+                    type: WireValueType.HANDLER,
                     name,
                     value: serializedValue,
                 },
@@ -334,7 +335,7 @@ function toWireValue(value) {
     }
     return [
         {
-            type: "RAW" /* WireValueType.RAW */,
+            type: WireValueType.RAW,
             value,
         },
         transferCache.get(value) || [],
@@ -342,9 +343,9 @@ function toWireValue(value) {
 }
 function fromWireValue(value) {
     switch (value.type) {
-        case "HANDLER" /* WireValueType.HANDLER */:
+        case WireValueType.HANDLER:
             return transferHandlers.get(value.name).deserialize(value.value);
-        case "RAW" /* WireValueType.RAW */:
+        case WireValueType.RAW:
             return value.value;
     }
 }
@@ -362,5 +363,5 @@ function generateUUID() {
     return new Array(4)
         .fill(0)
         .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-        .join("-");
+        .join('-');
 }

package/dist/comlink/index.d.ts

@@ -1 +1 @@
-export * from "./comlink";
+export * from './comlink';

package/dist/comlink/index.js

@@ -1 +1 @@
-export * from "./comlink";
+export * from './comlink';

package/dist/comlink/node-adapter.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Endpoint } from "./protocol";
+import type { Endpoint } from './protocol';
 export interface NodeEndpoint {
     postMessage(message: any, transfer?: any[]): void;
     on(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;

package/dist/comlink/node-adapter.js

@@ -9,14 +9,14 @@ export default function nodeEndpoint(nep) {
         postMessage: nep.postMessage.bind(nep),
         addEventListener: (_, eh) => {
             const l = (data) => {
-                if ("handleEvent" in eh) {
+                if ('handleEvent' in eh) {
                     eh.handleEvent({ data });
                 }
                 else {
                     eh({ data });
                 }
             };
-            nep.on("message", l);
+            nep.on('message', l);
             listeners.set(eh, l);
         },
         removeEventListener: (_, eh) => {
@@ -24,9 +24,9 @@ export default function nodeEndpoint(nep) {
             if (!l) {
                 return;
             }
-            nep.off("message", l);
+            nep.off('message', l);
             listeners.delete(eh);
         },
-        start: nep.start && nep.start.bind(nep),
+        start: nep.start?.bind(nep),
     };
 }

package/dist/comlink/protocol.d.ts

@@ -14,7 +14,7 @@ export interface Endpoint extends EventSource {
     postMessage(message: any, transfer?: Transferable[]): void;
     start?: () => void;
 }
-export declare const enum WireValueType {
+export declare enum WireValueType {
     RAW = "RAW",
     PROXY = "PROXY",
     THROW = "THROW",
@@ -33,7 +33,7 @@ export interface HandlerWireValue {
 }
 export type WireValue = RawWireValue | HandlerWireValue;
 export type MessageID = string;
-export declare const enum MessageType {
+export declare enum MessageType {
     GET = "GET",
     SET = "SET",
     APPLY = "APPLY",

package/dist/comlink/protocol.js

@@ -3,4 +3,19 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export {};
+export var WireValueType;
+(function (WireValueType) {
+    WireValueType["RAW"] = "RAW";
+    WireValueType["PROXY"] = "PROXY";
+    WireValueType["THROW"] = "THROW";
+    WireValueType["HANDLER"] = "HANDLER";
+})(WireValueType || (WireValueType = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType["GET"] = "GET";
+    MessageType["SET"] = "SET";
+    MessageType["APPLY"] = "APPLY";
+    MessageType["CONSTRUCT"] = "CONSTRUCT";
+    MessageType["ENDPOINT"] = "ENDPOINT";
+    MessageType["RELEASE"] = "RELEASE";
+})(MessageType || (MessageType = {}));

package/dist/helpers/endpoint.d.ts

@@ -1,19 +1,19 @@
-import { FrameHost } from "@farcaster/frame-core";
-import { Provider } from "ox";
-import { HostEndpoint } from "../types";
+import type { FrameHost } from '@farcaster/frame-core';
+import type { Provider } from 'ox';
+import type { HostEndpoint } from '../types';
 /**
  * @returns function to cleanup provider listeners
  */
 export declare function exposeToEndpoint({ endpoint, sdk, frameOrigin, ethProvider, debug, }: {
     endpoint: HostEndpoint;
-    sdk: Omit<FrameHost, "ethProviderRequestV2">;
+    sdk: Omit<FrameHost, 'ethProviderRequestV2'>;
     frameOrigin: string;
     ethProvider?: Provider.Provider;
     debug?: boolean;
 }): () => void;
 export declare function useExposeToEndpoint({ endpoint, sdk, frameOrigin, ethProvider, debug, }: {
     endpoint: HostEndpoint | undefined;
-    sdk: Omit<FrameHost, "ethProviderRequestV2">;
+    sdk: Omit<FrameHost, 'ethProviderRequestV2'>;
     frameOrigin: string;
     ethProvider?: Provider.Provider;
     debug?: boolean;

package/dist/helpers/endpoint.js

@@ -1,7 +1,7 @@
-import * as Comlink from "../comlink";
-import { forwardProviderEvents, wrapProviderRequest } from "./provider";
-import { wrapHandlers } from "./sdk";
-import { useEffect } from "react";
+import { useEffect } from 'react';
+import * as Comlink from '../comlink';
+import { forwardProviderEvents, wrapProviderRequest } from './provider';
+import { wrapHandlers } from './sdk';
 /**
  * @returns function to cleanup provider listeners
  */

package/dist/helpers/provider.d.ts

@@ -1,5 +1,5 @@
-import { Provider, RpcRequest, RpcResponse } from "ox";
-import { HostEndpoint } from "../types";
+import { Provider, type RpcRequest, RpcResponse } from 'ox';
+import type { HostEndpoint } from '../types';
 export declare function forwardProviderEvents({ provider, endpoint, }: {
     provider: Provider.Provider;
     endpoint: HostEndpoint;

package/dist/helpers/provider.js

@@ -1,31 +1,31 @@
-import { Provider, RpcResponse } from "ox";
+import { Provider, RpcResponse } from 'ox';
 export function forwardProviderEvents({ provider, endpoint, }) {
-    let accountsChanged = (accounts) => {
-        endpoint.emitEthProvider("accountsChanged", [accounts]);
+    const accountsChanged = (accounts) => {
+        endpoint.emitEthProvider('accountsChanged', [accounts]);
     };
-    let chainChanged = (chainId) => {
-        endpoint.emitEthProvider("chainChanged", [chainId]);
+    const chainChanged = (chainId) => {
+        endpoint.emitEthProvider('chainChanged', [chainId]);
     };
-    let connect = (connectInfo) => {
-        endpoint.emitEthProvider("connect", [connectInfo]);
+    const connect = (connectInfo) => {
+        endpoint.emitEthProvider('connect', [connectInfo]);
     };
-    let disconnect = (providerRpcError) => {
-        endpoint.emitEthProvider("disconnect", [providerRpcError]);
+    const disconnect = (providerRpcError) => {
+        endpoint.emitEthProvider('disconnect', [providerRpcError]);
     };
-    let message = (message) => {
-        endpoint.emitEthProvider("message", [message]);
+    const message = (message) => {
+        endpoint.emitEthProvider('message', [message]);
     };
-    provider.on("accountsChanged", accountsChanged);
-    provider.on("chainChanged", chainChanged);
-    provider.on("connect", connect);
-    provider.on("disconnect", disconnect);
-    provider.on("message", message);
+    provider.on('accountsChanged', accountsChanged);
+    provider.on('chainChanged', chainChanged);
+    provider.on('connect', connect);
+    provider.on('disconnect', disconnect);
+    provider.on('message', message);
     return () => {
-        provider.removeListener("accountsChanged", accountsChanged);
-        provider.removeListener("chainChanged", chainChanged);
-        provider.removeListener("connect", connect);
-        provider.removeListener("disconnect", disconnect);
-        provider.removeListener("message", message);
+        provider.removeListener('accountsChanged', accountsChanged);
+        provider.removeListener('chainChanged', chainChanged);
+        provider.removeListener('connect', connect);
+        provider.removeListener('disconnect', disconnect);
+        provider.removeListener('message', message);
     };
 }
 // export type FrameTransport<
@@ -39,18 +39,18 @@ export function forwardProviderEvents({ provider, endpoint, }) {
 export const wrapProviderRequest = ({ provider, debug = false, }) => async (request) => {
     try {
         if (debug) {
-            console.debug("[frame-host] eth provider req: ", request);
+            console.debug('[frame-host] eth provider req: ', request);
         }
         const result = await provider.request(request);
         const response = RpcResponse.from({ result }, { request });
         if (debug) {
-            console.debug("[frame-host] eth provider res: ", response);
+            console.debug('[frame-host] eth provider res: ', response);
         }
         return response;
     }
     catch (e) {
         if (debug) {
-            console.error("provider request error", e);
+            console.error('provider request error', e);
         }
         if (e instanceof Provider.ProviderRpcError) {
             return RpcResponse.from({
@@ -62,22 +62,22 @@ export const wrapProviderRequest = ({ provider, debug = false, }) => async (requ
             }, { request });
         }
         if (e !== null &&
-            typeof e === "object" &&
-            "message" in e &&
-            typeof e.message === "string" &&
-            "code" in e &&
-            typeof e.code === "number") {
+            typeof e === 'object' &&
+            'message' in e &&
+            typeof e.message === 'string' &&
+            'code' in e &&
+            typeof e.code === 'number') {
             return RpcResponse.from({
                 error: {
                     message: e.message,
                     code: e.code,
-                    details: "details" in e && typeof e.details === "string"
+                    details: 'details' in e && typeof e.details === 'string'
                         ? e.details
                         : undefined,
                 },
             }, { request });
         }
-        const errorMessage = e instanceof Error ? e.message : "Unknown";
+        const errorMessage = e instanceof Error ? e.message : 'Unknown';
         return RpcResponse.from({
             error: {
                 message: errorMessage,

package/dist/helpers/sdk.d.ts

@@ -1,2 +1,2 @@
-import type { FrameHost, WireFrameHost } from "@farcaster/frame-core";
+import type { FrameHost, WireFrameHost } from '@farcaster/frame-core';
 export declare function wrapHandlers(host: FrameHost): WireFrameHost;

package/dist/helpers/sdk.js

@@ -1,7 +1,30 @@
-import { SignIn } from "@farcaster/frame-core";
+import { AddFrame, SignIn } from '@farcaster/frame-core';
 export function wrapHandlers(host) {
     return {
         ...host,
+        addFrame: async () => {
+            try {
+                const result = await host.addFrame();
+                return { result };
+            }
+            catch (e) {
+                if (e instanceof AddFrame.RejectedByUser) {
+                    return {
+                        error: {
+                            type: 'rejected_by_user',
+                        },
+                    };
+                }
+                if (e instanceof AddFrame.InvalidDomainManifest) {
+                    return {
+                        error: {
+                            type: 'invalid_domain_manifest',
+                        },
+                    };
+                }
+                throw e;
+            }
+        },
         signIn: async (options) => {
             try {
                 const result = await host.signIn(options);
@@ -11,12 +34,12 @@ export function wrapHandlers(host) {
                 if (e instanceof SignIn.RejectedByUser) {
                     return {
                         error: {
-                            type: 'rejected_by_user'
-                        }
+                            type: 'rejected_by_user',
+                        },
                     };
                 }
                 throw e;
             }
-        }
+        },
     };
 }

package/dist/iframe.d.ts

@@ -1,6 +1,6 @@
-import type { Provider } from "ox";
-import { FrameHost } from "@farcaster/frame-core";
-import { HostEndpoint } from "./types";
+import type { FrameHost } from '@farcaster/frame-core';
+import type { Provider } from 'ox';
+import type { HostEndpoint } from './types';
 /**
  * An endpoint of communicating with an iFrame
  */
@@ -11,7 +11,7 @@ export declare function createIframeEndpoint({ iframe, targetOrigin, debug, }: {
 }): HostEndpoint;
 export declare function exposeToIframe({ iframe, sdk, ethProvider, frameOrigin, debug, }: {
     iframe: HTMLIFrameElement;
-    sdk: Omit<FrameHost, "ethProviderRequestV2">;
+    sdk: Omit<FrameHost, 'ethProviderRequestV2'>;
     frameOrigin: string;
     ethProvider?: Provider.Provider;
     debug?: boolean;

package/dist/iframe.js

@@ -1,5 +1,5 @@
-import * as Comlink from "./comlink";
-import { exposeToEndpoint } from "./helpers/endpoint";
+import * as Comlink from './comlink';
+import { exposeToEndpoint } from './helpers/endpoint';
 /**
  * An endpoint of communicating with an iFrame
  */
@@ -9,20 +9,20 @@ export function createIframeEndpoint({ iframe, targetOrigin, debug = true, }) {
         ...Comlink.windowEndpoint(iframe.contentWindow),
         emit: (event) => {
             if (debug) {
-                console.debug("frameEvent", event);
+                console.debug('frameEvent', event);
             }
             const wireEvent = {
-                type: "frameEvent",
+                type: 'frameEvent',
                 event,
             };
             iframe.contentWindow?.postMessage(wireEvent, targetOrigin);
         },
         emitEthProvider: (event, params) => {
             if (debug) {
-                console.debug("fc:emitEthProvider", event, params);
+                console.debug('fc:emitEthProvider', event, params);
             }
             const wireEvent = {
-                type: "frameEthProviderEvent",
+                type: 'frameEthProviderEvent',
                 event,
                 params,
             };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export * from "@farcaster/frame-core";
-export * from "./types";
-export * from "./iframe";
-export * from "./helpers/endpoint";
+export * from '@farcaster/frame-core';
+export * from './types';
+export * from './iframe';
+export * from './helpers/endpoint';

package/dist/index.js

@@ -1,4 +1,4 @@
-export * from "@farcaster/frame-core";
-export * from "./types";
-export * from "./iframe";
-export * from "./helpers/endpoint";
+export * from '@farcaster/frame-core';
+export * from './types';
+export * from './iframe';
+export * from './helpers/endpoint';