@farcaster/snap 2.1.2 → 2.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neynar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/colors.d.ts

@@ -24,6 +24,16 @@ export declare const PALETTE_COLOR_ACCENT: "accent";
 export declare const DEFAULT_THEME_ACCENT: "purple";
 export declare const PALETTE_COLOR_VALUES: readonly ["gray", "blue", "red", "amber", "green", "teal", "purple", "pink"];
 export type PaletteColor = (typeof PALETTE_COLOR_VALUES)[number];
+export declare function isSnapHexColorString(s: string): boolean;
+/**
+ * Resolve a snap color token for inline styles: `accent`, palette names, or
+ * literal `#rrggbb`. Unknown values fall back to `accentHex` (same as legacy
+ * `colorHex` behavior for non-hex strings).
+ */
+export declare function resolveSnapColorHex(color: string | undefined, opts: {
+    accentHex: string;
+    appearance: "light" | "dark";
+}): string;
 /** Light-mode hex for each palette color (emulator / reference client). */
 export declare const PALETTE_LIGHT_HEX: Record<PaletteColor, string>;
 /** Dark-mode hex for each palette color (reference). */

package/dist/colors.js

@@ -32,6 +32,28 @@ export const PALETTE_COLOR_VALUES = [
     PALETTE_COLOR.purple,
     PALETTE_COLOR.pink,
 ];
+/** Strict `#rrggbb` literal used by cell_grid (and clients that accept hex). */
+const SNAP_HEX_6 = /^#[0-9a-fA-F]{6}$/;
+export function isSnapHexColorString(s) {
+    return SNAP_HEX_6.test(s.trim());
+}
+/**
+ * Resolve a snap color token for inline styles: `accent`, palette names, or
+ * literal `#rrggbb`. Unknown values fall back to `accentHex` (same as legacy
+ * `colorHex` behavior for non-hex strings).
+ */
+export function resolveSnapColorHex(color, opts) {
+    if (!color || color === PALETTE_COLOR_ACCENT)
+        return opts.accentHex;
+    const trimmed = color.trim();
+    if (isSnapHexColorString(trimmed))
+        return trimmed;
+    const map = opts.appearance === "dark" ? PALETTE_DARK_HEX : PALETTE_LIGHT_HEX;
+    if (Object.hasOwn(map, trimmed)) {
+        return map[trimmed];
+    }
+    return opts.accentHex;
+}
 /** Light-mode hex for each palette color (emulator / reference client). */
 export const PALETTE_LIGHT_HEX = {
     gray: "#6E6A86",

package/dist/constants.d.ts

@@ -3,6 +3,7 @@ export declare const SPEC_VERSION_2: "2.0";
 export declare const SPEC_VERSION: "2.0";
 export declare const SUPPORTED_SPEC_VERSIONS: readonly ["1.0", "2.0"];
 export type SpecVersion = (typeof SUPPORTED_SPEC_VERSIONS)[number];
+export declare const SNAP_PAYLOAD_HEADER: "X-Snap-Payload";
 export declare const MEDIA_TYPE: "application/vnd.farcaster.snap+json";
 export declare const EFFECT_VALUES: readonly ["confetti"];
 export declare const POST_GRID_TAP_KEY: "grid_tap";

package/dist/constants.js

@@ -1,7 +1,11 @@
 export const SPEC_VERSION_1 = "1.0";
 export const SPEC_VERSION_2 = "2.0";
 export const SPEC_VERSION = SPEC_VERSION_2;
-export const SUPPORTED_SPEC_VERSIONS = [SPEC_VERSION_1, SPEC_VERSION_2];
+export const SUPPORTED_SPEC_VERSIONS = [
+    SPEC_VERSION_1,
+    SPEC_VERSION_2,
+];
+export const SNAP_PAYLOAD_HEADER = "X-Snap-Payload";
 export const MEDIA_TYPE = "application/vnd.farcaster.snap+json";
 export const EFFECT_VALUES = ["confetti"];
 // ─── Pixel grid ────────────────────────────────────────

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { Spec as SnapSpec, UIElement as SnapUIElement, } from "@json-render/core";
-export { SPEC_VERSION, SPEC_VERSION_1, SPEC_VERSION_2, SUPPORTED_SPEC_VERSIONS, type SpecVersion, MEDIA_TYPE, EFFECT_VALUES, POST_GRID_TAP_KEY, MAX_ELEMENTS, MAX_ROOT_CHILDREN, MAX_CHILDREN, MAX_DEPTH, } from "./constants.js";
-export { DEFAULT_THEME_ACCENT, PALETTE_COLOR, PALETTE_COLOR_ACCENT, PALETTE_COLOR_VALUES, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, type PaletteColor, } from "./colors.js";
-export { ACTION_TYPE_GET, ACTION_TYPE_POST, snapResponseSchema, payloadSchema, type SnapAction, type SnapContext, type SnapResponse, type SnapHandlerResult, type SnapElementInput, type SnapSpecInput, type SnapFunction, type SnapPayload, } from "./schemas.js";
+export { SPEC_VERSION, SPEC_VERSION_1, SPEC_VERSION_2, SUPPORTED_SPEC_VERSIONS, type SpecVersion, SNAP_PAYLOAD_HEADER, MEDIA_TYPE, EFFECT_VALUES, POST_GRID_TAP_KEY, MAX_ELEMENTS, MAX_ROOT_CHILDREN, MAX_CHILDREN, MAX_DEPTH, } from "./constants.js";
+export { DEFAULT_THEME_ACCENT, PALETTE_COLOR, PALETTE_COLOR_ACCENT, PALETTE_COLOR_VALUES, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, isSnapHexColorString, resolveSnapColorHex, type PaletteColor, } from "./colors.js";
+export { ACTION_TYPE_GET, ACTION_TYPE_POST, snapResponseSchema, payloadSchema, getPayloadSchema, type SnapAction, type SnapGetAction, type SnapContext, type SnapResponse, type SnapHandlerResult, type SnapElementInput, type SnapSpecInput, type SnapFunction, type SnapPayload, type SnapGetPayload, } from "./schemas.js";
 export { validateSnapResponse, type ValidationResult } from "./validator.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { SPEC_VERSION, SPEC_VERSION_1, SPEC_VERSION_2, SUPPORTED_SPEC_VERSIONS, MEDIA_TYPE, EFFECT_VALUES, POST_GRID_TAP_KEY, MAX_ELEMENTS, MAX_ROOT_CHILDREN, MAX_CHILDREN, MAX_DEPTH, } from "./constants.js";
-export { DEFAULT_THEME_ACCENT, PALETTE_COLOR, PALETTE_COLOR_ACCENT, PALETTE_COLOR_VALUES, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, } from "./colors.js";
-export { ACTION_TYPE_GET, ACTION_TYPE_POST, snapResponseSchema, payloadSchema, } from "./schemas.js";
+export { SPEC_VERSION, SPEC_VERSION_1, SPEC_VERSION_2, SUPPORTED_SPEC_VERSIONS, SNAP_PAYLOAD_HEADER, MEDIA_TYPE, EFFECT_VALUES, POST_GRID_TAP_KEY, MAX_ELEMENTS, MAX_ROOT_CHILDREN, MAX_CHILDREN, MAX_DEPTH, } from "./constants.js";
+export { DEFAULT_THEME_ACCENT, PALETTE_COLOR, PALETTE_COLOR_ACCENT, PALETTE_COLOR_VALUES, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, isSnapHexColorString, resolveSnapColorHex, } from "./colors.js";
+export { ACTION_TYPE_GET, ACTION_TYPE_POST, snapResponseSchema, payloadSchema, getPayloadSchema, } from "./schemas.js";
 export { validateSnapResponse } from "./validator.js";

package/dist/react/components/cell-grid.js

@@ -22,38 +22,46 @@ export function SnapCellGrid({ element: { props, on }, emit, }) {
     const name = props.name ? String(props.name) : POST_GRID_TAP_KEY;
     const tapPath = `/inputs/${name}`;
     const tapRaw = get(tapPath);
-    // Parse selection — single mode: "row,col" string; multi mode: "row,col|row,col|..." string
+    const cellMap = new Map();
+    for (const c of cells) {
+        cellMap.set(`${Number(c.row)},${Number(c.col)}`, {
+            color: c.color,
+            content: c.content != null ? String(c.content) : undefined,
+            value: typeof c.value === "string" ? c.value : undefined,
+        });
+    }
+    // Each cell's wire value — its `value` if set, otherwise "row,col" fallback.
+    const cellWireValue = (r, c) => cellMap.get(`${r},${c}`)?.value ?? `${r},${c}`;
+    // Multi mode joins values with `|`; single mode is the value itself.
     const selectedSet = new Set();
     if (typeof tapRaw === "string" && tapRaw.length > 0) {
-        for (const part of tapRaw.split("|")) {
-            if (part.includes(","))
-                selectedSet.add(part);
+        if (isMultiple) {
+            for (const part of tapRaw.split("|")) {
+                if (part.length > 0)
+                    selectedSet.add(part);
+            }
+        }
+        else {
+            selectedSet.add(tapRaw);
         }
     }
-    const isSelected = (r, c) => isSelectable && selectedSet.has(`${r},${c}`);
+    const isSelected = (r, c) => isSelectable && selectedSet.has(cellWireValue(r, c));
     const handleTap = (r, c) => {
-        const key = `${r},${c}`;
+        const wire = cellWireValue(r, c);
         if (isMultiple) {
             const next = new Set(selectedSet);
-            if (next.has(key))
-                next.delete(key);
+            if (next.has(wire))
+                next.delete(wire);
             else
-                next.add(key);
+                next.add(wire);
             set(tapPath, [...next].join("|"));
         }
         else {
-            set(tapPath, key);
+            set(tapPath, wire);
         }
         if (hasPressAction)
             emit("press");
     };
-    const cellMap = new Map();
-    for (const c of cells) {
-        cellMap.set(`${Number(c.row)},${Number(c.col)}`, {
-            color: c.color,
-            content: c.content != null ? String(c.content) : undefined,
-        });
-    }
     /** Cells without a palette `color` — subtle fill so empty slots read as tiles. */
     const emptyCellBg = colors.mode === "dark" ? "rgba(255, 255, 255, 0.05)" : "rgba(0, 0, 0, 0.05)";
     const cellEls = [];

package/dist/react/components/stack.js

@@ -1,7 +1,7 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { cn } from "@neynar/ui/utils";
-import { countRenderableChildren, horizontalChildrenAreAllButtons, } from "../../stack-horizontal-utils.js";
+import { countRenderableChildren, defaultHorizontalGapSize, horizontalChildrenAreAllButtons, } from "../../stack-horizontal-utils.js";
 import { SnapStackDirectionProvider, useSnapStackDirection, } from "../stack-direction-context.js";
 const VGAP = {
     none: "gap-0",
@@ -13,7 +13,7 @@ const HGAP = {
     none: "gap-0",
     sm: "gap-1",
     md: "gap-2",
-    lg: "gap-3",
+    lg: "gap-4",
 };
 const JUSTIFY_FLEX = {
     start: "justify-start",
@@ -34,11 +34,7 @@ const COLUMN_GRID_CLASS = {
 export function SnapStack({ element: { props }, children, }) {
     const parentDirection = useSnapStackDirection();
     const direction = String(props.direction ?? "vertical");
-    const gapKey = String(props.gap ?? "md");
     const isHorizontal = direction === "horizontal";
-    const gap = isHorizontal
-        ? (HGAP[gapKey] ?? "gap-2")
-        : (VGAP[gapKey] ?? "gap-4");
     const justifyKey = props.justify ? String(props.justify) : undefined;
     const justifyFlex = justifyKey ? JUSTIFY_FLEX[justifyKey] : undefined;
     const buttonRowGrid = isHorizontal && horizontalChildrenAreAllButtons(children);
@@ -52,6 +48,23 @@ export function SnapStack({ element: { props }, children, }) {
         Number.isInteger(columnsRaw)
         ? columnsRaw
         : undefined;
+    // Horizontal default depends on column count: 2→lg, 3→md, 4+→sm. Vertical stays md.
+    // Count comes from explicit `columns`, then button-row inference, else direct children
+    // count (any horizontal stack is N columns wide regardless of child types).
+    const horizontalColumnCount = isHorizontal
+        ? (columns ??
+            (buttonRowGrid ? buttonRowCount : undefined) ??
+            countRenderableChildren(children))
+        : undefined;
+    const explicitGap = typeof props.gap === "string" && props.gap in (isHorizontal ? HGAP : VGAP);
+    const gapKey = explicitGap
+        ? String(props.gap)
+        : isHorizontal
+            ? defaultHorizontalGapSize(horizontalColumnCount)
+            : "md";
+    const gap = isHorizontal
+        ? (HGAP[gapKey] ?? HGAP.md)
+        : (VGAP[gapKey] ?? VGAP.md);
     const explicitColumnGrid = isHorizontal && columns !== undefined && !buttonRowGrid;
     const columnGridClass = explicitColumnGrid && columns !== undefined
         ? COLUMN_GRID_CLASS[columns]

package/dist/react/components/text.js

@@ -18,6 +18,13 @@ export function SnapText({ element: { props }, }) {
     const stackDir = useSnapStackDirection();
     const inHorizontalStack = stackDir === "horizontal";
     return (_jsx(Text, { size: config.textSize, weight: weight, align: align, className: cn(
-        /** Row peers hug content like RN `wrapRow`; avoid `flex-1` stretching peers across the row. */
-        inHorizontalStack ? "min-w-0 shrink" : "flex-1"), style: { color: colors.text }, children: content }));
+        /**
+         * Row peers hug content like RN `wrapRow` — `min-w-0 shrink` lets text wrap
+         * inside a horizontal stack without forcing peers wide. In a vertical stack
+         * the `<p>` already fills its parent's width via `display: block`; avoid
+         * `flex-1` here because `flex-grow: 1` on a vertical-flex child fills the
+         * column's height, distributing siblings when the row is taller than its
+         * content (e.g. text next to a tall image).
+         */
+        inHorizontalStack ? "min-w-0 shrink" : "min-w-0"), style: { color: colors.text }, children: content }));
 }

package/dist/react/hooks/use-snap-colors.js

@@ -3,7 +3,7 @@ import { useMemo } from "react";
 import { useStateStore } from "@json-render/react";
 import { resolveSnapPaletteHex } from "../lib/resolve-palette-hex.js";
 import { useSnapPreviewPageAccent, useSnapAppearance } from "../accent-context.js";
-import { PALETTE_DARK_HEX, PALETTE_LIGHT_HEX } from "@farcaster/snap";
+import { resolveSnapColorHex } from "@farcaster/snap";
 /** Readable foreground color (black or white) for a given hex background. */
 export function pickForegroundForBg(hex) {
     const h = hex.replace(/^#/, "");
@@ -37,19 +37,12 @@ function buildSnapColors(accentName, mode) {
     const accent = resolveSnapPaletteHex(accentName, mode);
     const accentFg = pickForegroundForBg(accent);
     const neutrals = mode === "dark" ? NEUTRAL_DARK : NEUTRAL_LIGHT;
-    const paletteMap = mode === "dark" ? PALETTE_DARK_HEX : PALETTE_LIGHT_HEX;
     const accentHover = mode === "light"
         ? `color-mix(in srgb, ${accent} 82%, #000000)`
         : `color-mix(in srgb, ${accent} 78%, #ffffff)`;
     const outlineHover = `color-mix(in srgb, ${accent} 14%, ${neutrals.surface})`;
     const paletteHex = (name) => resolveSnapPaletteHex(name, mode);
-    const colorHex = (name) => {
-        if (!name || name === "accent")
-            return accent;
-        if (Object.hasOwn(paletteMap, name))
-            return paletteMap[name];
-        return accent;
-    };
+    const colorHex = (name) => resolveSnapColorHex(name, { accentHex: accent, appearance: mode });
     return {
         accent,
         accentFg,

package/dist/react-native/components/snap-cell-grid.js

@@ -25,37 +25,46 @@ export function SnapCellGrid({ element, emit, }) {
     const name = props.name ? String(props.name) : POST_GRID_TAP_KEY;
     const tapPath = `/inputs/${name}`;
     const tapRaw = get(tapPath);
+    const cellMap = new Map();
+    for (const c of cells) {
+        cellMap.set(`${Number(c.row)},${Number(c.col)}`, {
+            color: c.color,
+            content: c.content != null ? String(c.content) : undefined,
+            value: typeof c.value === "string" ? c.value : undefined,
+        });
+    }
+    // Each cell's wire value — its `value` if set, otherwise "row,col" fallback.
+    const cellWireValue = (r, c) => cellMap.get(`${r},${c}`)?.value ?? `${r},${c}`;
+    // Multi mode joins values with `|`; single mode is the value itself.
     const selectedSet = new Set();
     if (typeof tapRaw === "string" && tapRaw.length > 0) {
-        for (const part of tapRaw.split("|")) {
-            if (part.includes(","))
-                selectedSet.add(part);
+        if (isMultiple) {
+            for (const part of tapRaw.split("|")) {
+                if (part.length > 0)
+                    selectedSet.add(part);
+            }
+        }
+        else {
+            selectedSet.add(tapRaw);
         }
     }
-    const isSelected = (r, c) => isSelectable && selectedSet.has(`${r},${c}`);
+    const isSelected = (r, c) => isSelectable && selectedSet.has(cellWireValue(r, c));
     const handleTap = (r, c) => {
-        const key = `${r},${c}`;
+        const wire = cellWireValue(r, c);
         if (isMultiple) {
             const next = new Set(selectedSet);
-            if (next.has(key))
-                next.delete(key);
+            if (next.has(wire))
+                next.delete(wire);
             else
-                next.add(key);
+                next.add(wire);
             set(tapPath, [...next].join("|"));
         }
         else {
-            set(tapPath, key);
+            set(tapPath, wire);
         }
         if (hasPressAction)
             emit("press");
     };
-    const cellMap = new Map();
-    for (const c of cells) {
-        cellMap.set(`${Number(c.row)},${Number(c.col)}`, {
-            color: c.color,
-            content: c.content != null ? String(c.content) : undefined,
-        });
-    }
     const ringOuter = appearance === "dark" ? "#fff" : "#000";
     const ringInner = appearance === "dark" ? "#000" : "#fff";
     /** Cells without a palette `color` — subtle fill so empty slots read as tiles. */

package/dist/react-native/components/snap-stack.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Children } from "react";
 import { StyleSheet, View } from "react-native";
-import { countRenderableChildren, horizontalChildrenAreAllButtons, } from "../../stack-horizontal-utils.js";
+import { countRenderableChildren, defaultHorizontalGapSize, horizontalChildrenAreAllButtons, } from "../../stack-horizontal-utils.js";
 import { SnapStackDirectionProvider, useSnapStackDirection, } from "../stack-direction-context.js";
 const VGAP = {
     none: 0,
@@ -13,7 +13,7 @@ const HGAP = {
     none: 0,
     sm: 4,
     md: 8,
-    lg: 12,
+    lg: 16,
 };
 const JUSTIFY = {
     start: "flex-start",
@@ -33,11 +33,6 @@ export function SnapStack({ element: { props }, children, }) {
     const rawGap = props.gap;
     const isHorizontal = direction === "horizontal";
     const gapMap = isHorizontal ? HGAP : VGAP;
-    const gap = typeof rawGap === "number"
-        ? rawGap
-        : typeof rawGap === "string" && rawGap in gapMap
-            ? gapMap[rawGap]
-            : isHorizontal ? HGAP.md : VGAP.md;
     const buttonRowGrid = isHorizontal && horizontalChildrenAreAllButtons(children);
     const buttonRowCount = buttonRowGrid
         ? countRenderableChildren(children)
@@ -49,6 +44,21 @@ export function SnapStack({ element: { props }, children, }) {
         Number.isInteger(columnsRaw)
         ? columnsRaw
         : undefined;
+    // Horizontal default depends on column count: 2→lg, 3→md, 4+→sm. Vertical stays md.
+    // Count comes from explicit `columns`, then button-row inference, else direct children
+    // count (any horizontal stack is N columns wide regardless of child types).
+    const horizontalColumnCount = isHorizontal
+        ? (columns ??
+            (buttonRowGrid ? buttonRowCount : undefined) ??
+            countRenderableChildren(children))
+        : undefined;
+    const gap = typeof rawGap === "number"
+        ? rawGap
+        : typeof rawGap === "string" && rawGap in gapMap
+            ? gapMap[rawGap]
+            : isHorizontal
+                ? gapMap[defaultHorizontalGapSize(horizontalColumnCount)]
+                : VGAP.md;
     const explicitColumnGrid = isHorizontal && columns !== undefined && !buttonRowGrid;
     const justify = props.justify &&
         (!isHorizontal || (!buttonRowGrid && !explicitColumnGrid))

package/dist/react-native/use-snap-palette.js

@@ -1,4 +1,4 @@
-import { DEFAULT_THEME_ACCENT, PALETTE_COLOR_VALUES, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, } from "@farcaster/snap";
+import { DEFAULT_THEME_ACCENT, PALETTE_COLOR_VALUES, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, resolveSnapColorHex, } from "@farcaster/snap";
 import { useStateStore } from "@json-render/react-native";
 import { useSnapTheme } from "./theme.js";
 function resolveHex(name, appearance) {
@@ -23,7 +23,7 @@ export function useSnapPalette() {
     const { get } = useStateStore();
     const accentName = themeAccentFromStore(get);
     const accentHex = resolveHex(accentName, mode);
-    const hex = (semantic) => semantic === "accent" ? accentHex : resolveHex(semantic, mode);
+    const hex = (semantic) => resolveSnapColorHex(semantic, { accentHex, appearance: mode });
     return { appearance: mode, accentName, accentHex, hex };
 }
 /** `#RRGGBB` + alpha → `rgba(...)` for React Native styles. */

package/dist/schemas.d.ts

@@ -89,10 +89,46 @@ export declare const payloadSchema: z.ZodObject<{
     }, z.core.$strip>], "type">;
 }, z.core.$strip>;
 export type SnapPayload = z.infer<typeof payloadSchema>;
+/** JFS payload shape for POST minus deprecated `fid`; used for GET auth via payload header. */
+export declare const getPayloadSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        fid: z.ZodNumber;
+    }, z.core.$strip>;
+    timestamp: z.ZodNumber;
+    audience: z.ZodString;
+    surface: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"cast">;
+        cast: z.ZodObject<{
+            hash: z.ZodString;
+            author: z.ZodObject<{
+                fid: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"standalone">;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+export type SnapGetPayload = z.infer<typeof getPayloadSchema>;
 export declare const ACTION_TYPE_GET: "get";
 export declare const ACTION_TYPE_POST: "post";
 declare const snapGetActionSchema: z.ZodObject<{
     type: z.ZodLiteral<"get">;
+    user: z.ZodOptional<z.ZodObject<{
+        fid: z.ZodNumber;
+    }, z.core.$strip>>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    audience: z.ZodOptional<z.ZodString>;
+    surface: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"cast">;
+        cast: z.ZodObject<{
+            hash: z.ZodString;
+            author: z.ZodObject<{
+                fid: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"standalone">;
+    }, z.core.$strip>], "type">>;
 }, z.core.$strip>;
 export type SnapGetAction = z.infer<typeof snapGetActionSchema>;
 declare const snapPostActionSchema: z.ZodObject<{
@@ -119,6 +155,22 @@ declare const snapPostActionSchema: z.ZodObject<{
 export type SnapPostAction = z.infer<typeof snapPostActionSchema>;
 export declare const snapActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"get">;
+    user: z.ZodOptional<z.ZodObject<{
+        fid: z.ZodNumber;
+    }, z.core.$strip>>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    audience: z.ZodOptional<z.ZodString>;
+    surface: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"cast">;
+        cast: z.ZodObject<{
+            hash: z.ZodString;
+            author: z.ZodObject<{
+                fid: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"standalone">;
+    }, z.core.$strip>], "type">>;
 }, z.core.$strip>, z.ZodObject<{
     fid: z.ZodOptional<z.ZodNumber>;
     inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;

package/dist/schemas.js

@@ -47,22 +47,28 @@ const surfaceSchema = z.discriminatedUnion("type", [
     castSurfaceSchema,
     standaloneSurfaceSchema,
 ]);
+const fidSchema = z.number().int().nonnegative();
+const userSchema = z.object({ fid: fidSchema });
 export const payloadSchema = z
     .object({
-    fid: z.number().int().nonnegative().optional(), // deprecated in favor of user.fid
+    fid: fidSchema.optional(), // deprecated in favor of user.fid
     inputs: z.record(z.string(), postInputValueSchema).default({}),
     timestamp: z.number().int(),
     audience: z.string(),
-    user: z.object({
-        fid: z.number().int().nonnegative(),
-    }),
+    user: userSchema,
     surface: surfaceSchema,
 })
     .strip();
+/** JFS payload shape for POST minus deprecated `fid`; used for GET auth via payload header. */
+export const getPayloadSchema = payloadSchema.omit({ inputs: true, fid: true });
 export const ACTION_TYPE_GET = "get";
 export const ACTION_TYPE_POST = "post";
 const snapGetActionSchema = z.object({
     type: z.literal(ACTION_TYPE_GET),
+    user: userSchema.optional(),
+    timestamp: z.number().int().optional(),
+    audience: z.string().optional(),
+    surface: surfaceSchema.optional(),
 });
 const snapPostActionSchema = payloadSchema.extend({
     type: z.literal(ACTION_TYPE_POST),

package/dist/server/index.d.ts

@@ -1,3 +1,4 @@
-export { verifyJFSRequestBody, decodePayload, encodePayload } from "./verify.js";
+export { verifyJFS as verifyJFSRequestBody, // deprecated alias. drop in v3
+parseJfs, verifyJFS, decodePayload, encodePayload, } from "./verify.js";
 export { DEFAULT_SNAP_HUB_HTTP_BASE_URL, getActiveEd25519SignerKeysFromHubHttp, } from "./hubs.js";
 export { parseRequest, type ParseRequestError, type ParseRequestOptions, type ParseRequestResult, } from "./parseRequest.js";

package/dist/server/index.js

@@ -1,3 +1,4 @@
-export { verifyJFSRequestBody, decodePayload, encodePayload } from "./verify.js";
+export { verifyJFS as verifyJFSRequestBody, // deprecated alias. drop in v3
+parseJfs, verifyJFS, decodePayload, encodePayload, } from "./verify.js";
 export { DEFAULT_SNAP_HUB_HTTP_BASE_URL, getActiveEd25519SignerKeysFromHubHttp, } from "./hubs.js";
 export { parseRequest, } from "./parseRequest.js";

package/dist/server/parseRequest.d.ts

@@ -1,5 +1,5 @@
-import { type SnapAction } from "../schemas.js";
 import { z } from "zod";
+import { type SnapAction } from "../schemas.js";
 export type ParseRequestError = {
     type: "method_not_allowed";
     message: string;
@@ -47,7 +47,8 @@ export type ParseRequestResult = {
 };
 /**
  * Parse and validate Farcaster snap requests:
- * - `GET` is allowed for first-page loads and returns `{ type: "get" }`.
- * - `POST`: the body must be JSON in JFS form (`header` / `payload` / `signature`) even if JFS verification is skipped.
+ * - `GET`: returns `{ type: "get" }`, or optional viewer fields when `X-Snap-Payload`
+ *   carries a JFS compact string whose decoded payload validates against {@link getPayloadSchema}.
+ * - `POST`: the body must be a JFS envelope — either JSON `{ header, payload, signature }` or the same **compact** string form as GET (`BASE64URL(header).BASE64URL(payload).BASE64URL(signature)`), even if JFS verification is skipped.
  */
 export declare function parseRequest(request: Request, options?: ParseRequestOptions): Promise<ParseRequestResult>;