@voltro/client 0.55.0 → 0.57.0

package/dist/form.js

@@ -1,2 +1,2 @@
-import { C as e, S as t, _ as n, a as r, b as i, g as a, i as o, n as s, o as c, r as l, t as u, v as d, w as f, x as p, y as m } from "./formData-DtlF8t8h.js";
+import { C as e, S as t, _ as n, a as r, b as i, g as a, i as o, n as s, o as c, r as l, t as u, v as d, w as f, x as p, y as m } from "./formData-He_L4ozH.js";
 export { u as FORM_FLASH_SCRIPT_ID, s as FORM_KEY_FIELD, l as FORM_PATH_PREFIX, o as FORM_REDIRECT_FIELD, a as decodeFieldIssues, n as documentLocale, r as formActionPath, c as formDataToInput, p as formField, t as formSections, d as resolveValidationMessage, m as restrictToSchema, e as schemaToColumns, f as schemaToFields, i as validateFields };

package/dist/{formData-DtlF8t8h.js → formData-He_L4ozH.js}

@@ -187,17 +187,20 @@ var r = (e) => ({ jsonSchema: { "x-voltro": e } }), i = "#/$defs/", a = (e) => e
 		"validation.invalidFileType": "Dieser Dateityp ist nicht erlaubt",
 		"validation.fileTooLarge": "Die Datei ist zu groß"
 	}
-}, b = (e, t) => e.replace(/\{(\w+)\}/g, (e, n) => {
-	let r = t?.[n];
-	return r === void 0 ? e : String(r);
-}), x = () => {
+}, b = (e, t) => {
+	let n = !1, r = e.replace(/\{(\w+)\}/g, (e, r) => {
+		let i = t?.[r];
+		return i === void 0 ? (n = !0, e) : String(i);
+	});
+	return n ? void 0 : r;
+}, x = () => {
 	let e = globalThis.document?.documentElement?.lang ?? "";
 	return e === "" ? "en" : e;
 }, S = (e, t) => {
 	let n = t?.messages?.(e.id, e.params, e.fallback);
 	if (n !== void 0) return n;
 	let r = y[(t?.locale ?? x()).toLowerCase().split("-")[0] ?? "en"]?.[e.id] ?? y.en?.[e.id];
-	return r === void 0 ? e.fallback : b(r, e.params);
+	return (r === void 0 ? void 0 : b(r, e.params)) ?? e.fallback;
 }, C = (e) => {
 	let t = /^([a-z][\w-]*(?:\.[\w-]+)+)\|(\{.*\})$/.exec(e);
 	if (t !== null && t[1] !== void 0 && t[2] !== void 0) try {

package/dist/index.d.ts

@@ -960,6 +960,15 @@ export declare interface EventValidation {
     readonly errors: Readonly<Record<string, string>>;
 }
 
+/** One currently-failing tag. */
+export declare interface FailedCall {
+    readonly tag: string;
+    readonly source: 'mutation' | 'action' | 'subscription';
+    readonly error: unknown;
+    /** When it failed, so a UI can say "since 12:04" rather than only "broken". */
+    readonly at: number;
+}
+
 export declare interface FieldDescriptor {
     /** Property name on the input object. */
     readonly name: string;
@@ -1283,15 +1292,40 @@ export declare interface FrameworkRuntimes {
     readonly get: (name: string) => ApiHandle;
     /** Enumerate the names of currently-installed apis (for debug). */
     readonly names: ReadonlyArray<string>;
+    /**
+     * "Something in this tree needs `apiName`."
+     *
+     * Under `web.api.connect: 'lazy'` the provider does not open a socket until
+     * this is called, so a page that reads no data never opens one. Under the
+     * default `'eager'` it is a no-op — every api connects at mount, as before.
+     *
+     * It exists because the alternative was worse in a specific, measured way:
+     * `interactive: 'full'` is the DEFAULT render mode, and the client opened a
+     * WebSocket on every such page whether or not it subscribed. A pre-rendered
+     * documentation page with no data at all opened one (measured in a real
+     * browser: 0 sockets on `interactive: 'none'` / `'islands'`, one on `'full'`).
+     * And an open socket keeps a dormancy-managed instance awake — `isIdleNow`
+     * returns false while `connectedClients() > 0` — so one browser tab on a
+     * pricing page prevented scale-to-zero indefinitely.
+     *
+     * Optional so a foreign host embedding `FrameworkRuntimesContext` by hand
+     * keeps working; absent means "already connected", which is the safe reading.
+     */
+    readonly demand?: (apiName: string) => void;
 }
 
 export declare const FrameworkRuntimesContext: Context<FrameworkRuntimes | null>;
 
-export declare const FrameworkRuntimesProvider: ({ apis, children, }: FrameworkRuntimesProviderProps) => ReactNode;
+export declare const FrameworkRuntimesProvider: ({ apis, children, demand, }: FrameworkRuntimesProviderProps) => ReactNode;
 
 export declare interface FrameworkRuntimesProviderProps {
     readonly apis: ReadonlyMap<string, ApiHandle>;
     readonly children: ReactNode;
+    /** Passed straight through to the context so `useFrameworkApi` can say that
+     *  something in the tree needs an api. The web boot supplies it under
+     *  `web.api.connect: 'lazy'`; a foreign host may omit it, which reads as
+     *  "already connected". */
+    readonly demand?: (apiName: string) => void;
 }
 
 /** Browser-safe unique idempotency key: prefer `crypto.randomUUID`, fall back to
@@ -2052,7 +2086,17 @@ export declare interface ResumableAgentStreamState<E> {
     /** The UNWRAPPED inner events received so far, in order (deduped by seq). */
     readonly events: ReadonlyArray<E>;
     readonly status: ResumableStreamStatus;
-    /** How many times the transport dropped + auto-reconnected this run. */
+    /**
+     * How many times the transport dropped + auto-reconnected this run — the
+     * RUN TOTAL, which is NOT the number `maxReconnects` bounds.
+     *
+     * `maxReconnects` is a ceiling on CONSECUTIVE reconnects that made no
+     * progress, and the counter behind it resets whenever a reconnect delivers an
+     * event. So this total can exceed it on a long, healthy stream, and rendering
+     * "attempt {reconnects} of {maxReconnects}" puts `5/2` on the screen — which
+     * is what a deployment saw. The two names sit next to each other and read as a
+     * pair; they are not one, and there is no third field that is.
+     */
     readonly reconnects: number;
     /** Set when status === 'error'. */
     readonly error: unknown | undefined;
@@ -2455,10 +2499,50 @@ export declare class RpcErrorBus {
     on(listener: RpcErrorListener): () => void;
     /** Emit. Pipeline code (useMutation / subscriptionCache) calls this. */
     emit(event: RpcError): void;
+    /**
+     * Subscribe to SUCCESSES — the channel that makes a consecutive-failure
+     * ceiling mean what it says.
+     *
+     * ── Why the bus grew a second channel ──────────────────────────────────
+     *
+     * `wireAuthRefresh` bounds how often it may rebuild the transport on
+     * `Unauthenticated`, and `maxConsecutive` bounds the TOTAL — after that many
+     * refreshes *with no successful call in between*, it stops and leaves the
+     * error to the app, because at that point the credential is not stale, it is
+     * refused. "With no successful call in between" was carried by
+     * `AuthRefreshHandle.noteSuccess()`, a method the HOST had to remember to
+     * call, and the only host never called it.
+     *
+     * What that turns the ceiling into is the part worth writing down: not a
+     * loop, but a LIFETIME budget. A tab that rotates its token three times over
+     * a few hours exhausts it and then never refreshes again for as long as it
+     * stays open — every later expiry rejects every subscription it opens, each
+     * rejected entry is terminal for its transport, and the screen waits on a
+     * spinner that has nothing left to wait for.
+     *
+     * A host that must remember something will eventually not, which is the
+     * shape this repo keeps meeting. So the signal comes from the pipeline that
+     * already knows — the same one that emits the errors — and no host has to
+     * wire anything. `noteSuccess()` stays for a host with a better signal of its
+     * own; it is no longer what the policy depends on.
+     */
+    onSuccess(listener: RpcSuccessListener): () => void;
+    /** Emit a success. Called by the same pipeline code that calls `emit`. */
+    emitSuccess(event: RpcSuccess): void;
 }
 
 export declare type RpcErrorListener = (event: RpcError) => void;
 
+/** A call that SUCCEEDED. Carries only its source and tag — there is no payload
+ *  here on purpose: this channel exists so cross-cutting policy can tell
+ *  "working again" from "still broken", not so listeners can read data. */
+export declare interface RpcSuccess {
+    readonly source: 'mutation' | 'action' | 'subscription';
+    readonly tag: string;
+}
+
+export declare type RpcSuccessListener = (event: RpcSuccess) => void;
+
 /**
  * Run a sequence. Resolves with a discriminated result rather than rejecting —
  * the same "handled" semantics `useMutation`/`useAction` use, so the call site
@@ -3218,6 +3302,14 @@ export declare interface SubscriptionFailed extends SubscriptionMeta {
     readonly error: unknown;
 }
 
+export declare interface SubscriptionHealth {
+    /** Every tag whose last outcome on this api was a failure, newest first. */
+    readonly failed: ReadonlyArray<FailedCall>;
+    /** `false` as soon as anything is failing — the positive form, so a component
+     *  reads `if (!healthy)` instead of `if (failed.length > 0)`. */
+    readonly healthy: boolean;
+}
+
 /**
  * Deliberately NOT subscribed — `skip: true`.
  *
@@ -3715,6 +3807,13 @@ export declare type UploadStatus = 'idle' | 'uploading' | 'success' | 'error';
  *  `<PermissionProvider>`. The hook form of `decideAccess`. */
 export declare const useAccessDecision: (guards: ReadonlyArray<ManifestGuard> | undefined) => AccessDecision;
 
+/**
+ * Invoke a server `defineAction` procedure by tag. Unlike `useMutation`,
+ * an action has no optimistic / cache surface — it's a unary call whose
+ * effects (sends, captures, side-effecting writes the framework must NOT
+ * preview locally) only become visible when the server pushes a delta on
+ * an independent subscription.
+ */
 export declare const useAction: <Input = unknown, Output = unknown>(apiName: string, rpcTag: string) => ActionState<Input, Output>;
 
 export declare const useAgent: (apiName: string, rpcTag: string) => AgentControls;
@@ -3858,7 +3957,26 @@ export declare interface UseEventOptions {
     readonly apiName?: string;
 }
 
-export declare const useFormBinding: <Input extends Record<string, unknown> = Record<string, unknown>, Output = unknown>(apiName: string, mutationTag: string, options: UseFormBindingOptions<Input>) => FormBinding<Input, Output>;
+export declare const useFormBinding: <Input extends Record<string, unknown> = Record<string, unknown>, Output = unknown>(apiName: string, 
+/**
+ * The mutation to submit to — a tag, or a FUNCTION of the current values.
+ *
+ * The function form exists for the case where the form decides which mutation
+ * it is: a calendar entry becomes a recurring SERIES the moment "repeats" is
+ * ticked, and the series mutation takes eleven more fields. Deriving the tag
+ * outside the binding is not available — the values belong to the binding and
+ * do not exist before it — and re-mounting with a different tag resets the
+ * engine, which throws away everything the user has typed.
+ *
+ * It does not: the engine is constructed once and never rebuilt, so the tag
+ * may change on any render and the values, touched state and errors all
+ * survive it. What changes with the tag is the SCHEMA the binding validates
+ * against, which is the point.
+ *
+ * On the first render there are no values yet, so the function is called with
+ * the seeded defaults — the same thing the user is looking at.
+ */
+mutationTag: string | ((values: Partial<Input>) => string), options: UseFormBindingOptions<Input>) => FormBinding<Input, Output>;
 
 /** The enclosing binding, if a {@link FormBindingProvider} is mounted. */
 export declare const useFormBindingContext: () => FormBinding<Record<string, unknown>, unknown> | undefined;
@@ -4153,6 +4271,19 @@ export declare function useSubscription<T = unknown>(apiName: string, rpcTag: st
     readonly skip?: boolean;
 }): SubscriptionState<T> | SubscriptionIdle;
 
+/**
+ * The api's currently-refused calls.
+ *
+ * A tag enters the list when a call for it fails and LEAVES it when a call for
+ * the same tag succeeds — keyed by tag rather than counted, because the
+ * question a screen asks is "is this working now", and two failures of one tag
+ * are one broken thing.
+ *
+ *     const { healthy, failed } = useSubscriptionHealth('app')
+ *     if (!healthy) return <Banner tags={failed.map((f) => f.tag)} />
+ */
+export declare const useSubscriptionHealth: (apiName: string) => SubscriptionHealth;
+
 /** The column shape a `<DataTable query=…>` will render — from the query's
  *  output Schema. */
 export declare const useTableSkeleton: (apiName: string, queryTag: string) => ReadonlyArray<FieldDescriptor>;