@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.4

package/dist/lib/attempt.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Failure custody for kit code: run work and carry its value or its failure
+ * as a value, never dropped. The shape mirrors the runtime's own `Settled`
+ * (`@vibesdotdev/kernel` reload generations); kit keeps this copy because
+ * kit components import no framework runtime.
+ *
+ * Call sites branch on `ok` and carry a typed result or refusal. A failure is
+ * reported by its class (`failureClass`), never by its value.
+ */
+/** A recorded failure: the thrown value, kept as thrown (it may be any value, even `undefined`). */
+export interface RecordedFailure {
+    readonly error: unknown;
+}
+/** A step's outcome: its value, or its failure carried as a value. */
+export type Settled<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | ({
+    readonly ok: false;
+} & RecordedFailure);
+/** Run `work` and carry its value or its failure. */
+export declare function settle<T>(work: () => T | PromiseLike<T>): Promise<Settled<T>>;
+/** Run synchronous `work` and carry its value or its failure. */
+export declare function settleNow<T>(work: () => T): Settled<T>;

package/dist/lib/attempt.js

@@ -0,0 +1,27 @@
+/**
+ * Failure custody for kit code: run work and carry its value or its failure
+ * as a value, never dropped. The shape mirrors the runtime's own `Settled`
+ * (`@vibesdotdev/kernel` reload generations); kit keeps this copy because
+ * kit components import no framework runtime.
+ *
+ * Call sites branch on `ok` and carry a typed result or refusal. A failure is
+ * reported by its class (`failureClass`), never by its value.
+ */
+/** Run `work` and carry its value or its failure. */
+export async function settle(work) {
+    try {
+        return { ok: true, value: await work() };
+    }
+    catch (error) {
+        return { ok: false, error };
+    }
+}
+/** Run synchronous `work` and carry its value or its failure. */
+export function settleNow(work) {
+    try {
+        return { ok: true, value: work() };
+    }
+    catch (error) {
+        return { ok: false, error };
+    }
+}

package/dist/lib/billing/plan-normalizer.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Plan/Tier Slug Normalization Utilities
+ *
+ * Provides configurable plan slug normalization without coupling to
+ * application-specific billing constants.
+ * Applications configure this with their tier definitions and use the exported singleton.
+ */
+export interface PlanNormalizerConfig {
+    /** Canonical tier slugs in priority order (e.g., ['free', 'standard', 'plus', 'pro']) */
+    canonicalTiers: readonly string[];
+    /** Tier synonyms mapping (e.g., {'standard-team': 'team-standard'}) */
+    tierSynonyms?: Record<string, string>;
+    /** Billing cycle suffixes to strip (e.g., ['monthly', 'yearly', 'trial']) */
+    billingSuffixes?: Set<string>;
+}
+declare class PlanNormalizer {
+    private config;
+    /**
+     * Configure the normalizer with tier definitions
+     * Should be called once during app initialization
+     */
+    configure(config: PlanNormalizerConfig): void;
+    private ensureConfigured;
+    /**
+     * Normalize any plan or tier slug into a canonical tier slug.
+     * Returns null when no matching tier is discovered.
+     */
+    normalizeTierSlug(slug: string | null | undefined): string | null;
+    /**
+     * Derive a normalized comparison key for plan gating.
+     * Canonical tiers are preferred, but we also map known enterprise/platform aliases.
+     */
+    normalizePlanComparisonValue(slug: string | null | undefined): string | null;
+    /**
+     * Check if a slug is a valid tier slug
+     */
+    isValidTierSlug(slug: string | null | undefined): boolean;
+    /**
+     * Get the canonical tier priority order
+     */
+    getCanonicalTierPriority(): readonly string[];
+    /**
+     * Compare two tier slugs by priority.
+     *
+     * @returns negative if `a` is lower priority than `b`, zero if equal, positive if higher.
+     *          Returns 0 if either slug is unknown.
+     */
+    comparePlanPriority(a: string, b: string): number;
+    /**
+     * Check whether the current tier meets or exceeds the minimum tier.
+     *
+     * @param current  - The user's active tier slug
+     * @param minimum  - The minimum tier slug required
+     * @returns true if `current` is at least `minimum` in the priority ordering
+     */
+    isPlanAtLeast(current: string, minimum: string): boolean;
+    /**
+     * Check whether the current tier slug is one of the allowed slugs.
+     *
+     * @param current - The user's active tier slug
+     * @param plans   - Array of tier slugs to match against
+     * @returns true if `current` is in `plans`
+     */
+    isPlanOneOf(current: string, plans: string[]): boolean;
+}
+/**
+ * Global singleton instance
+ * Configure once during app initialization, then import and use throughout the app
+ */
+export declare const planNormalizer: PlanNormalizer;
+export {};

package/dist/lib/billing/plan-normalizer.js

@@ -0,0 +1,145 @@
+/**
+ * Plan/Tier Slug Normalization Utilities
+ *
+ * Provides configurable plan slug normalization without coupling to
+ * application-specific billing constants.
+ * Applications configure this with their tier definitions and use the exported singleton.
+ */
+class PlanNormalizer {
+    config = null;
+    /**
+     * Configure the normalizer with tier definitions
+     * Should be called once during app initialization
+     */
+    configure(config) {
+        this.config = config;
+    }
+    ensureConfigured() {
+        if (!this.config) {
+            throw new Error('PlanNormalizer not configured. Call configure() during app initialization.');
+        }
+        return this.config;
+    }
+    /**
+     * Normalize any plan or tier slug into a canonical tier slug.
+     * Returns null when no matching tier is discovered.
+     */
+    normalizeTierSlug(slug) {
+        if (!slug)
+            return null;
+        const config = this.ensureConfigured();
+        const lowered = slug.toLowerCase().replace(/_/g, '-');
+        const candidates = new Set([lowered]);
+        const synonyms = config.tierSynonyms || {};
+        if (lowered in synonyms) {
+            candidates.add(synonyms[lowered]);
+        }
+        const parts = lowered.split('-').filter(Boolean);
+        for (let i = 0; i < parts.length; i++) {
+            let combo = parts[i];
+            candidates.add(combo);
+            if (combo in synonyms) {
+                candidates.add(synonyms[combo]);
+            }
+            for (let j = i + 1; j < parts.length; j++) {
+                combo = `${combo}-${parts[j]}`;
+                candidates.add(combo);
+                if (combo in synonyms) {
+                    candidates.add(synonyms[combo]);
+                }
+            }
+        }
+        // Sort by length descending to prefer longer matches
+        const prioritizedTiers = [...config.canonicalTiers].sort((a, b) => b.length - a.length);
+        for (const tier of prioritizedTiers) {
+            if (candidates.has(tier)) {
+                return tier;
+            }
+        }
+        return null;
+    }
+    /**
+     * Derive a normalized comparison key for plan gating.
+     * Canonical tiers are preferred, but we also map known enterprise/platform aliases.
+     */
+    normalizePlanComparisonValue(slug) {
+        if (!slug)
+            return null;
+        const config = this.ensureConfigured();
+        const lowered = slug.toLowerCase().replace(/_/g, '-');
+        // Special cases for top-tier plans
+        if (lowered.includes('platform'))
+            return 'platform';
+        if (lowered.includes('enterprise'))
+            return 'enterprise';
+        const tier = this.normalizeTierSlug(slug);
+        if (tier)
+            return tier;
+        const synonyms = config.tierSynonyms || {};
+        if (lowered in synonyms)
+            return synonyms[lowered];
+        const parts = lowered.split('-').filter(Boolean);
+        const billingSuffixes = config.billingSuffixes || new Set(['monthly', 'yearly', 'trial']);
+        const filtered = parts.filter((part) => !billingSuffixes.has(part));
+        return filtered[0] ?? parts[0] ?? null;
+    }
+    /**
+     * Check if a slug is a valid tier slug
+     */
+    isValidTierSlug(slug) {
+        return Boolean(this.normalizeTierSlug(slug ?? undefined));
+    }
+    /**
+     * Get the canonical tier priority order
+     */
+    getCanonicalTierPriority() {
+        const config = this.ensureConfigured();
+        return config.canonicalTiers;
+    }
+    /**
+     * Compare two tier slugs by priority.
+     *
+     * @returns negative if `a` is lower priority than `b`, zero if equal, positive if higher.
+     *          Returns 0 if either slug is unknown.
+     */
+    comparePlanPriority(a, b) {
+        const config = this.ensureConfigured();
+        const indexA = config.canonicalTiers.indexOf(a);
+        const indexB = config.canonicalTiers.indexOf(b);
+        // Unknown slugs compare as equal to avoid accidental lockouts
+        if (indexA === -1 || indexB === -1)
+            return 0;
+        return indexA - indexB;
+    }
+    /**
+     * Check whether the current tier meets or exceeds the minimum tier.
+     *
+     * @param current  - The user's active tier slug
+     * @param minimum  - The minimum tier slug required
+     * @returns true if `current` is at least `minimum` in the priority ordering
+     */
+    isPlanAtLeast(current, minimum) {
+        const config = this.ensureConfigured();
+        const indexCurrent = config.canonicalTiers.indexOf(current);
+        const indexMinimum = config.canonicalTiers.indexOf(minimum);
+        // An unrecognized current or policy tier is not proof of entitlement.
+        if (indexCurrent === -1 || indexMinimum === -1)
+            return false;
+        return indexCurrent >= indexMinimum;
+    }
+    /**
+     * Check whether the current tier slug is one of the allowed slugs.
+     *
+     * @param current - The user's active tier slug
+     * @param plans   - Array of tier slugs to match against
+     * @returns true if `current` is in `plans`
+     */
+    isPlanOneOf(current, plans) {
+        return plans.includes(current);
+    }
+}
+/**
+ * Global singleton instance
+ * Configure once during app initialization, then import and use throughout the app
+ */
+export const planNormalizer = new PlanNormalizer();

package/dist/lib/browser-csp/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The one Content-Security-Policy source for every vibes SvelteKit app.
+ *
+ * Replaces ~17 hand-copied `browser-csp.mjs` files (four divergent shapes; six
+ * of them silently missing the entries their own shell needed). An app's
+ * `svelte.config.js` imports `createVibesAppCsp()` and passes only its genuine
+ * variations as options — there is no hand-maintained policy left to drift.
+ *
+ * The theme and dark-mode first-paint bootstraps are delivered without inline
+ * scripts (theme CSS from `assets.vibes.dev`, dark-mode class SSR'd from the
+ * `vibes-mode` cookie), so this policy carries NO inline-script hashes: nonce
+ * mode covers SvelteKit's own scripts, and there is nothing app-specific to
+ * allow-list. Kit's AppShell and ProductShell defaults match that contract;
+ * direct SharedModeWatcher consumers must explicitly disable its compatibility
+ * bootstrap when they adopt this policy.
+ */
+export type CspSource = string;
+export type CspDirectives = Record<string, CspSource[]>;
+export interface VibesAppCspOptions {
+    /**
+     * Base domains the fleet origins are derived from. Defaults to the public
+     * fleet (`vibes.dev`) plus its local-dev sibling (`vibes.local`). Overriding
+     * is only for a fleet that does not use those names.
+     */
+    baseDomains?: string[];
+    /**
+     * Enable the Cloudflare Web Analytics beacon sources
+     * (`static.cloudflareinsights.com` in script-src, `cloudflareinsights.com`
+     * in connect-src). Omit and the beacon is not allow-listed — omission turns
+     * the capability off. Only enable it on an app that actually injects the
+     * beacon hook.
+     */
+    webAnalytics?: boolean;
+    /** Extra `script-src` / `script-src-elem` sources beyond the baseline. */
+    scriptSrc?: CspSource[];
+    /** Extra `connect-src` sources (fleet + local-dev defaults always included). */
+    connectSrc?: CspSource[];
+    /** Extra `style-src` / `style-src-elem` sources (self, assets, account origins always included). */
+    styleSrc?: CspSource[];
+    /** Extra `img-src` sources. */
+    imgSrc?: CspSource[];
+    /** Extra `font-src` sources. */
+    fontSrc?: CspSource[];
+    /** Extra `form-action` targets (fleet defaults always included). */
+    formAction?: CspSource[];
+    /** Extra `worker-src` sources. */
+    workerSrc?: CspSource[];
+    /** Override `frame-ancestors` (default `['none']`). */
+    frameAncestors?: CspSource[];
+}
+/**
+ * Build the fleet-standard CSP directives for a vibes app.
+ *
+ * Every directive here is intentionally explicit and structural: the four
+ * "minimal" apps in the old set were under-specified (no `*-elem`, no
+ * `font-src`/`worker-src`, `connect-src` collapsed to a bare `https:`
+ * wildcard), which is a gap to correct, not a shape to preserve.
+ */
+export declare function createVibesAppCsp(options?: VibesAppCspOptions): {
+    'default-src': string[];
+    'script-src': string[];
+    'script-src-elem': string[];
+    'style-src': string[];
+    'style-src-elem': string[];
+    'img-src': string[];
+    'font-src': string[];
+    'connect-src': string[];
+    'worker-src': string[];
+    'frame-ancestors': string[];
+    'base-uri': string[];
+    'form-action': string[];
+};

package/dist/lib/browser-csp/index.js

@@ -0,0 +1,79 @@
+/**
+ * The one Content-Security-Policy source for every vibes SvelteKit app.
+ *
+ * Replaces ~17 hand-copied `browser-csp.mjs` files (four divergent shapes; six
+ * of them silently missing the entries their own shell needed). An app's
+ * `svelte.config.js` imports `createVibesAppCsp()` and passes only its genuine
+ * variations as options — there is no hand-maintained policy left to drift.
+ *
+ * The theme and dark-mode first-paint bootstraps are delivered without inline
+ * scripts (theme CSS from `assets.vibes.dev`, dark-mode class SSR'd from the
+ * `vibes-mode` cookie), so this policy carries NO inline-script hashes: nonce
+ * mode covers SvelteKit's own scripts, and there is nothing app-specific to
+ * allow-list. Kit's AppShell and ProductShell defaults match that contract;
+ * direct SharedModeWatcher consumers must explicitly disable its compatibility
+ * bootstrap when they adopt this policy.
+ */
+const DEFAULT_BASE_DOMAINS = ['vibes.dev', 'vibes.local'];
+const LOCAL_DEV_HOSTS = ['http://localhost:*', 'http://127.0.0.1:*', 'http://0.0.0.0:*'];
+const LOCAL_DEV_WS = ['ws://localhost:*', 'ws://127.0.0.1:*'];
+const CF_INSIGHTS_SCRIPT = 'https://static.cloudflareinsights.com';
+const CF_INSIGHTS_CONNECT = 'https://cloudflareinsights.com';
+function dedupe(sources) {
+    return [...new Set(sources.filter((source) => source.length > 0))];
+}
+/**
+ * Build the fleet-standard CSP directives for a vibes app.
+ *
+ * Every directive here is intentionally explicit and structural: the four
+ * "minimal" apps in the old set were under-specified (no `*-elem`, no
+ * `font-src`/`worker-src`, `connect-src` collapsed to a bare `https:`
+ * wildcard), which is a gap to correct, not a shape to preserve.
+ */
+export function createVibesAppCsp(options = {}) {
+    const baseDomains = options.baseDomains ?? DEFAULT_BASE_DOMAINS;
+    const httpsFleet = baseDomains.flatMap((domain) => [`https://${domain}`, `https://*.${domain}`]);
+    const wssFleet = baseDomains.map((domain) => `wss://*.${domain}`);
+    const assetsOrigins = baseDomains.map((domain) => `https://assets.${domain}`);
+    const accountOrigins = baseDomains.map((domain) => `https://account.${domain}`);
+    const scriptSrc = dedupe([
+        'self',
+        'wasm-unsafe-eval',
+        ...(options.webAnalytics ? [CF_INSIGHTS_SCRIPT] : []),
+        ...(options.scriptSrc ?? [])
+    ]);
+    const styleSrc = dedupe([
+        'self',
+        'unsafe-inline',
+        // Cross-origin theme delivery: built-in preset CSS from the shared assets
+        // domain, signed-in custom CSS from the account app (deferred).
+        ...assetsOrigins,
+        ...accountOrigins,
+        ...LOCAL_DEV_HOSTS,
+        ...(options.styleSrc ?? [])
+    ]);
+    const connectSrc = dedupe([
+        'self',
+        ...httpsFleet,
+        ...LOCAL_DEV_HOSTS,
+        ...LOCAL_DEV_WS,
+        ...wssFleet,
+        ...(options.webAnalytics ? [CF_INSIGHTS_CONNECT] : []),
+        ...(options.connectSrc ?? [])
+    ]);
+    const formAction = dedupe(['self', ...httpsFleet, ...(options.formAction ?? [])]);
+    return {
+        'default-src': ['self'],
+        'script-src': scriptSrc,
+        'script-src-elem': scriptSrc,
+        'style-src': styleSrc,
+        'style-src-elem': styleSrc,
+        'img-src': dedupe(['self', 'data:', 'blob:', 'https:', ...(options.imgSrc ?? [])]),
+        'font-src': dedupe(['self', 'data:', 'https:', ...assetsOrigins, ...(options.fontSrc ?? [])]),
+        'connect-src': connectSrc,
+        'worker-src': dedupe(['self', 'blob:', ...(options.workerSrc ?? [])]),
+        'frame-ancestors': options.frameAncestors ?? ['none'],
+        'base-uri': ['self'],
+        'form-action': formAction
+    };
+}

package/dist/lib/browser-csp/shared-mode-ssr.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SvelteKit hook that stamps an explicit shared light/dark preference onto the
+ * root `<html>` element during SSR. `system` and absent preferences remain
+ * untouched so CSS `prefers-color-scheme` stays authoritative.
+ */
+import type { Handle, RequestEvent } from '@sveltejs/kit';
+export interface SharedModeSsrOptions {
+    /** Cookie read by the hook. Defaults to `vibes-mode`. */
+    cookieName?: string;
+    /** Class applied for dark mode and removed for light mode. Defaults to `dark`. */
+    darkClass?: string;
+    /** Request-local presentation resolved by a domain loader before rendering. */
+    resolvePresentation?: (event: RequestEvent) => {
+        mode?: 'light' | 'dark' | 'system';
+        attributes?: Record<string, string>;
+        classes?: Record<string, boolean>;
+    } | undefined;
+}
+export declare function createSharedModeSsrHook(options?: SharedModeSsrOptions): Handle;

package/dist/lib/browser-csp/shared-mode-ssr.js

@@ -0,0 +1,74 @@
+import { SHARED_MODE_COOKIE_NAME, readSharedModeCookie } from "../components/ui/mode-switcher/shared-mode-sync.js";
+const HTML_TAG = /<html\b([^>]*)>/i;
+const CSS_CLASS_NAME = /^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/;
+export function createSharedModeSsrHook(options = {}) {
+    const cookieName = options.cookieName ?? SHARED_MODE_COOKIE_NAME;
+    const darkClass = options.darkClass ?? 'dark';
+    if (!CSS_CLASS_NAME.test(darkClass)) {
+        throw new Error(`Shared mode SSR darkClass must be one CSS class name: ${darkClass}`);
+    }
+    return async ({ event, resolve }) => {
+        const mode = readSharedModeCookie(event.request.headers.get('cookie') ?? '', cookieName);
+        if (mode !== 'light' && mode !== 'dark' && !options.resolvePresentation)
+            return resolve(event);
+        return resolve(event, {
+            transformPageChunk: ({ html }) => {
+                const presentation = options.resolvePresentation?.(event);
+                const effectiveMode = presentation?.mode ?? mode;
+                const result = effectiveMode === 'light' || effectiveMode === 'dark'
+                    ? stampSharedMode(html, effectiveMode, darkClass)
+                    : html;
+                if (!presentation)
+                    return result;
+                return result.replace(HTML_TAG, (_match, rawAttributes) => {
+                    let attributes = rawAttributes;
+                    if (effectiveMode === 'system') {
+                        attributes = setModeClass(setModeClass(attributes, 'light', darkClass), 'light', 'light');
+                        attributes = attributes.replace(/\sdata-mode\s*=\s*(["']).*?\1/i, '');
+                    }
+                    for (const [name, value] of Object.entries(presentation.attributes ?? {})) {
+                        if (!/^data-[a-z][a-z0-9-]*$/.test(name))
+                            throw new Error(`Invalid presentation attribute: ${name}`);
+                        attributes = setQuotedAttribute(attributes, name, value
+                            .replace(/&/g, '&amp;')
+                            .replace(/"/g, '&quot;')
+                            .replace(/'/g, '&#39;')
+                            .replace(/</g, '&lt;'));
+                    }
+                    for (const [name, enabled] of Object.entries(presentation.classes ?? {})) {
+                        if (!CSS_CLASS_NAME.test(name))
+                            throw new Error(`Invalid presentation class: ${name}`);
+                        attributes = setModeClass(attributes, enabled ? 'dark' : 'light', name);
+                    }
+                    return `<html${attributes}>`;
+                });
+            }
+        });
+    };
+}
+function stampSharedMode(html, mode, darkClass) {
+    return html.replace(HTML_TAG, (_match, rawAttributes) => {
+        let attributes = setModeClass(rawAttributes, mode, darkClass);
+        attributes = setQuotedAttribute(attributes, 'data-mode', mode);
+        return `<html${attributes}>`;
+    });
+}
+function setModeClass(attributes, mode, darkClass) {
+    const classPattern = /(\bclass\s*=\s*)(["'])(.*?)\2/i;
+    const match = attributes.match(classPattern);
+    const classes = (match?.[3] ?? '').split(/\s+/).filter(Boolean);
+    const next = classes.filter((className) => className !== darkClass);
+    if (mode === 'dark')
+        next.push(darkClass);
+    if (match) {
+        return attributes.replace(classPattern, () => `${match[1]}${match[2]}${next.join(' ')}${match[2]}`);
+    }
+    return mode === 'dark' ? `${attributes} class="${darkClass}"` : attributes;
+}
+function setQuotedAttribute(attributes, name, value) {
+    const pattern = new RegExp(`(\\b${name}\\s*=\\s*)(["'])(.*?)\\2`, 'i');
+    const match = attributes.match(pattern);
+    if (!match)
+        return `${attributes} ${name}="${value}"`;
+    return attributes.replace(pattern, () => `${match[1]}${match[2]}${value}${match[2]}`);
+}

package/dist/lib/client/core.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vibes Client Core for Kit consumers.
+ *
+ * This is the canonical Kit client export. The implementation stays inside
+ * Kit so the public package has one explicit client contract.
+ */
+export { VibesClient } from './internal/vibes-client.js';
+export type { SSEEvent } from './internal/sse-stream.js';
+export type { ClientConfig, AuthConfig, ClientHooks, ClientError } from './types.js';

package/dist/lib/client/core.js

@@ -0,0 +1,7 @@
+/**
+ * Vibes Client Core for Kit consumers.
+ *
+ * This is the canonical Kit client export. The implementation stays inside
+ * Kit so the public package has one explicit client contract.
+ */
+export { VibesClient } from './internal/vibes-client.js';

package/dist/lib/client/form-action.d.ts

@@ -0,0 +1,50 @@
+import * as z from 'zod/v4';
+/**
+ * A value an action may return. SvelteKit's `deserialize` has already decoded these
+ * (devalue), so Kit does not re-validate the values, only the result envelope.
+ */
+export type FormActionValue = string | number | boolean | bigint | null | undefined | Date | URL | RegExp | Map<FormActionValue, FormActionValue> | Set<FormActionValue> | FormActionValue[] | {
+    [key: string]: FormActionValue;
+};
+export type FormActionData = Record<string, FormActionValue>;
+export type FormActionDecodedData<TData extends FormActionData> = Partial<Omit<TData, 'error'>> & FormActionData & {
+    error?: string;
+};
+export interface SubmitFormActionOptions {
+    fetch?: typeof fetch;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
+/** The action result envelope SvelteKit's `deserialize` returns. */
+declare const FormActionEnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<FormActionValue, FormActionValue>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"failure">;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<FormActionValue, FormActionValue>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"redirect">;
+}, z.core.$loose>], "type">;
+export type FormActionEnvelope = z.input<typeof FormActionEnvelopeSchema>;
+export type FormActionDeserializer = (text: string) => FormActionEnvelope;
+export interface FormActionResult<TData extends FormActionData = FormActionData> {
+    response: Response;
+    data: FormActionDecodedData<TData>;
+}
+/**
+ * Submit a SvelteKit form action without navigating and decode its action result.
+ *
+ * This is the client-side equivalent of an enhanced form submission for controls
+ * that cannot use `use:enhance`, such as confirmation dialogs and toolbar buttons.
+ */
+export declare function submitSvelteKitFormAction<TData extends FormActionData = FormActionData>(url: string | URL, formData: FormData, deserialize: FormActionDeserializer, options?: SubmitFormActionOptions): Promise<FormActionResult<TData>>;
+export declare function readFormActionData<TData extends FormActionData = FormActionData>(response: Response, deserialize: FormActionDeserializer): Promise<FormActionDecodedData<TData>>;
+export declare function createFormActionClient(deserialize: FormActionDeserializer): {
+    submitSvelteKitFormAction: <TData extends FormActionData = FormActionData>(url: string | URL, formData: FormData, options?: SubmitFormActionOptions) => Promise<FormActionResult<TData>>;
+    readFormActionData: <TData extends FormActionData = FormActionData>(response: Response) => Promise<FormActionDecodedData<TData>>;
+};
+export declare function formActionMessage(data: FormActionData, keys: string[], fallback: string): string;
+export {};