@nsail/stack 0.0.0-stage → 0.1.135

package/dist/catalogs/strings.es.json

@@ -0,0 +1,165 @@
+{
+  "Common.Submit": "Guardar",
+  "Common.Filter": "Buscar",
+  "Common.Search": "Escribí para buscar",
+  "Common.SearchPrompt": "Buscar {0}",
+  "Common.CreateNew": "Crear {0}...",
+  "Common.QuickAdd": "Agregar «{0}»",
+  "Common.NoOptions": "Todavía no hay {0} para elegir.",
+  "Common.Filters": "Filtros",
+  "Common.FiltersCount": "Filtros ({0})",
+  "Common.New": "Nuevo",
+  "Common.Quick": "Rápido",
+  "Common.Loading": "Cargando",
+  "Common.Menu": "Menú",
+  "Common.MoreActions": "Más acciones",
+  "Common.ShowOptions": "Mostrar opciones",
+  "Common.LoadMore": "Cargar más",
+  "Common.SelectPage": "Seleccionar las filas de esta página",
+  "Common.SelectRow": "Seleccionar fila",
+  "Common.Selected": "{0} seleccionado",
+  "Common.Selected.Plural": "{0} seleccionados",
+  "Common.SelectAll": "Seleccionar la única fila",
+  "Common.SelectAll.Plural": "Seleccionar los {0}",
+  "Common.ClearSelection": "Quitar selección",
+  "Common.Enabled": "Habilitado",
+  "Actions.Add": "Agregar",
+  "Actions.Edit": "Editar",
+  "Actions.Delete": "Eliminar",
+  "Actions.Confirm": "Confirmar",
+  "Actions.Cancel": "Cancelar",
+  "Actions.Export": "Exportar",
+  "Actions.ExportExcel": "Excel",
+  "Actions.ExportCsv": "CSV",
+  "Actions.ExportPdf": "PDF",
+  "Common.Auto": "Automático",
+  "Common.All": "Todos",
+  "Common.Close": "Salir",
+  "Common.SkipToContent": "Saltar al contenido",
+  "Common.Help": "Ayuda",
+  "Common.Details": "Detalle",
+  "Common.Guide": "Ayuda",
+  "Common.GuideMissing": "No se pudo leer este capítulo del manual.",
+  "Common.Saved": "Guardado",
+  "Common.RowsPerPage": "Filas por página",
+  "Common.UnsavedChanges": "Tenés cambios sin guardar. ¿Seguro que querés salir?",
+  "Common.UnsavedChangesTitle": "Cambios sin guardar",
+  "Common.ConfirmSend": "¿Confirmás esta acción?",
+  "Common.InUse": "Este registro está en uso y no se puede borrar. Para dejar de verlo, deshabilitalo.",
+  "Common.Confirm": "Confirmar",
+  "Common.Alert": "Aviso",
+  "Common.Yes": "Sí",
+  "Common.No": "No",
+  "Common.Ok": "Aceptar",
+  "Common.Upload": "Subir",
+  "Common.File": "Archivo",
+  "Common.NoFile": "Ningún archivo elegido",
+  "Common.FileTooLarge": "El archivo supera los {0} MB",
+  "Common.DateLetters": "dma",
+  "Common.Hours": "h",
+  "Common.Back": "Atrás",
+  "Common.Next": "Siguiente",
+  "Common.Finish": "Finalizar",
+  "Common.Home": "Inicio",
+  "Common.PageNotFound": "Esta página no existe.",
+  "Common.NotAuthorized": "No tenés permiso para acceder a esta página. Probá cambiar de organización desde el menú de usuario.",
+  "Common.UnhandledError": "Algo se rompió.",
+  "Common.ErrorReference": "Referencia {handle}",
+  "Common.Reload": "Recargar",
+  "Common.Retry": "Reintentar",
+  "Common.NewVersion": "Hay una versión nueva.",
+
+  "Components.NsPasswordField.Stored": "Guardado. Vacío para conservarlo.",
+
+  "Components.PasswordStrength.Weak": "Débil",
+  "Components.PasswordStrength.Medium": "Media",
+  "Components.PasswordStrength.Strong": "Fuerte",
+
+  "Problems.RuleViolation.Title": "No se pudo completar la operación",
+  "Problems.InvalidState.Title": "Estado inválido",
+  "Problems.InvalidState": "Estado inválido: {state}",
+  "Problems.NotFound.Title": "No se encontró el recurso",
+  "Problems.NotFound": "No se encontró {entity}",
+  "Problems.Conflict.Title": "Conflicto de concurrencia",
+  "Problems.Conflict": "Alguien más lo modificó mientras lo editabas",
+  "Problems.ConflictAt": "Alguien más lo modificó el {at}, mientras lo editabas",
+  "Problems.AlreadyExists.Title": "El recurso ya existe",
+  "Problems.AlreadyExists": "Ya existe {entity} con el valor {value}",
+  "Problems.InsufficientStock.Title": "Stock insuficiente",
+  "Problems.InsufficientStock": "Stock insuficiente de {product}: quedan {available}",
+  "Problems.MissingTaxRate.Title": "Falta la alícuota",
+  "Problems.MissingTaxRate": "El producto {product} no tiene alícuota asignada",
+  "Problems.MissingPrice.Title": "Falta el precio",
+  "Problems.MissingPrice": "El producto {product} no tiene precio en la Lista de Venta",
+
+  "Problems.InvalidModel.Title": "Hay campos con datos inválidos",
+  "Problems.Required": "Obligatorio",
+  "Problems.InvalidFormat": "Formato inválido",
+  "Problems.UnreadableDate": "Esto no es una fecha — escribila como {shape}",
+  "Problems.UnreadableAddress": "Esto no es una dirección web — escribila completa, como https://ejemplo.com",
+  "Problems.UnreadableAddressDomain": "Esto no es una dirección web — revisá el dominio",
+  "Problems.OutOfRange": "Fuera de rango",
+  "Problems.MaxLength": "No más de {max} caracteres",
+  "Problems.NotFuture": "No puede ser posterior a hoy",
+  "Problems.NotNegative": "No puede ser menor que cero",
+  "Problems.NotPositive": "No puede ser mayor que cero",
+  "Problems.PositiveAmount": "Tiene que ser mayor que cero",
+  "Problems.NotAbove": "No puede ser mayor que el límite superior",
+  "Problems.Mismatch": "Los dos valores no coinciden",
+  "Problems.Invalid": "Valor inválido",
+  "Problems.BadRequest": "No se pudo interpretar el pedido",
+
+  "Problems.Unauthorized.Title": "Falta autenticación",
+  "Problems.Unauthorized": "Tenés que iniciar sesión para hacer esto",
+  "Problems.Forbidden.Title": "Acceso denegado",
+  "Problems.Forbidden": "No tenés permiso para hacer esto",
+
+  "Problems.TooManyRequests.Title": "Demasiados intentos",
+  "Problems.TooManyRequests": "Demasiados intentos. Esperá un momento y probá de nuevo",
+
+  "Problems.InternalError.Title": "Ocurrió un error inesperado",
+  "Problems.InternalError": "Algo falló de nuestro lado",
+  "Problems.Unknown.Title": "Ocurrió un error desconocido",
+  "Problems.Unknown": "Algo salió mal",
+  "Problems.Canceled.Title": "Operación cancelada",
+
+  "Problems.RequestFailed.Title": "No se pudo contactar al servidor",
+  "Problems.NoResponse": "El servidor no respondió",
+  "Problems.HttpStatus": "El servidor respondió con un error",
+  "Problems.EmptyResponse": "El servidor devolvió una respuesta vacía",
+  "Problems.DeserializationFailed": "No se pudo leer la respuesta del servidor",
+  "Problems.StatusFallback": "",
+
+  "Mud.MudDataGridPager_RowsPerPage": "Filas por página:",
+  "Mud.MudDataGridPager_InfoFormat": "{0}-{1} de {2}",
+  "Mud.MudDataGridPager_AllItems": "Todos",
+  "Mud.MudTablePager_FirstPage": "Primera página",
+  "Mud.MudTablePager_PreviousPage": "Página anterior",
+  "Mud.MudTablePager_NextPage": "Página siguiente",
+  "Mud.MudTablePager_LastPage": "Última página",
+  "Mud.MudTable_Loading": "Cargando...",
+  "Mud.MudTreeView_ExpandItem": "Expandir",
+  "Mud.MudTreeView_CollapseItem": "Contraer",
+  "Mud.MudNavGroup_ToggleExpand": "Expandir",
+  "Mud.MudInput_Clear": "Limpiar",
+  "Mud.MudSnackbar_Close": "Cerrar",
+  "Mud.MudAlert_Close": "Cerrar",
+  "Mud.MudDialog_Close": "Cerrar",
+  "Mud.MudChip_Close": "Quitar",
+  "Mud.MudBaseDatePicker_Open": "Abrir calendario",
+  "Mud.MudBaseDatePicker_PrevMonth": "Mes anterior",
+  "Mud.MudBaseDatePicker_NextMonth": "Mes siguiente",
+  "Mud.MudBaseDatePicker_PrevYear": "Año anterior",
+  "Mud.MudBaseDatePicker_NextYear": "Año siguiente",
+  "Mud.MudTimePicker_Open": "Abrir reloj",
+  "Common.NoRecords": "No hay registros para mostrar",
+  "Common.TimeGridHiddenDay": "Mostrando {day} — 1 día más de esta semana está oculto para entrar",
+  "Common.TimeGridHiddenDay.Plural": "Mostrando {day} — {count} días más de esta semana están ocultos para entrar",
+
+  "Problems.Timeout.Title": "La operación tardó demasiado",
+  "Problems.Timeout": "La operación tardó demasiado en completarse",
+  "Problems.ExternalTimeout.Title": "Un servicio tardó demasiado en responder",
+  "Problems.ExternalServiceUnavailable.Title": "Un servicio no está disponible",
+
+  "Common.Resource": "Recurso"
+}

package/dist/catalogs/strings.json

@@ -0,0 +1,165 @@
+{
+  "Common.Submit": "Save",
+  "Common.Filter": "Search",
+  "Common.Search": "Type to search",
+  "Common.SearchPrompt": "Search {0}",
+  "Common.CreateNew": "Create {0}...",
+  "Common.QuickAdd": "Add \"{0}\"",
+  "Common.NoOptions": "There is no {0} to pick yet.",
+  "Common.Filters": "Filters",
+  "Common.FiltersCount": "Filters ({0})",
+  "Common.New": "New",
+  "Common.Quick": "Quick",
+  "Common.Loading": "Loading",
+  "Common.Menu": "Menu",
+  "Common.MoreActions": "More actions",
+  "Common.ShowOptions": "Show options",
+  "Common.LoadMore": "Load more",
+  "Common.SelectPage": "Select the rows on this page",
+  "Common.SelectRow": "Select row",
+  "Common.Selected": "{0} selected",
+  "Common.Selected.Plural": "{0} selected",
+  "Common.SelectAll": "Select the {0} row",
+  "Common.SelectAll.Plural": "Select all {0}",
+  "Common.ClearSelection": "Clear selection",
+  "Common.Enabled": "Enabled",
+  "Actions.Add": "Add",
+  "Actions.Edit": "Edit",
+  "Actions.Delete": "Delete",
+  "Actions.Confirm": "Confirm",
+  "Actions.Cancel": "Cancel",
+  "Actions.Export": "Export",
+  "Actions.ExportExcel": "Excel",
+  "Actions.ExportCsv": "CSV",
+  "Actions.ExportPdf": "PDF",
+  "Common.Auto": "Auto",
+  "Common.All": "All",
+  "Common.Close": "Close",
+  "Common.SkipToContent": "Skip to content",
+  "Common.Help": "Help",
+  "Common.Details": "Details",
+  "Common.Guide": "Guide",
+  "Common.GuideMissing": "This chapter of the guide could not be read.",
+  "Common.Saved": "Saved",
+  "Common.RowsPerPage": "Rows per page",
+  "Common.UnsavedChanges": "You have unsaved changes. Are you sure you want to leave?",
+  "Common.UnsavedChangesTitle": "Unsaved changes",
+  "Common.ConfirmSend": "Confirm this action?",
+  "Common.InUse": "This record is in use and cannot be deleted. To stop seeing it, disable it.",
+  "Common.Confirm": "Confirm",
+  "Common.Alert": "Alert",
+  "Common.Yes": "Yes",
+  "Common.No": "No",
+  "Common.Ok": "OK",
+  "Common.Upload": "Upload",
+  "Common.File": "File",
+  "Common.NoFile": "No file chosen",
+  "Common.FileTooLarge": "The file is larger than {0} MB",
+  "Common.DateLetters": "dmy",
+  "Common.Hours": "h",
+  "Common.Back": "Back",
+  "Common.Next": "Next",
+  "Common.Finish": "Finish",
+  "Common.Home": "Home",
+  "Common.PageNotFound": "This page does not exist.",
+  "Common.NotAuthorized": "You do not have permission to access this page. Try changing your organization from the user menu.",
+  "Common.UnhandledError": "Something broke.",
+  "Common.ErrorReference": "Reference {handle}",
+  "Common.Reload": "Reload",
+  "Common.Retry": "Retry",
+  "Common.NewVersion": "A new version is available.",
+
+  "Components.NsPasswordField.Stored": "Stored. Leave this empty to keep it.",
+
+  "Components.PasswordStrength.Weak": "Weak",
+  "Components.PasswordStrength.Medium": "Medium",
+  "Components.PasswordStrength.Strong": "Strong",
+
+  "Problems.RuleViolation.Title": "The operation could not be completed",
+  "Problems.InvalidState.Title": "Invalid state",
+  "Problems.InvalidState": "Invalid state: {state}",
+  "Problems.NotFound.Title": "Resource not found",
+  "Problems.NotFound": "{entity} was not found",
+  "Problems.Conflict.Title": "Concurrency conflict",
+  "Problems.Conflict": "Someone else changed this while you were editing it",
+  "Problems.ConflictAt": "Someone else changed this on {at}, while you were editing it",
+  "Problems.AlreadyExists.Title": "Resource already exists",
+  "Problems.AlreadyExists": "{entity} with value {value} already exists",
+  "Problems.InsufficientStock.Title": "Insufficient stock",
+  "Problems.InsufficientStock": "Insufficient stock of {product}: {available} available",
+  "Problems.MissingTaxRate.Title": "Missing tax rate",
+  "Problems.MissingTaxRate": "{product} has no tax rate assigned",
+  "Problems.MissingPrice.Title": "Missing price",
+  "Problems.MissingPrice": "{product} has no price the selling list can resolve",
+
+  "Problems.InvalidModel.Title": "One or more fields contain invalid data",
+  "Problems.Required": "Required",
+  "Problems.InvalidFormat": "Invalid format",
+  "Problems.UnreadableDate": "This is not a date — write it as {shape}",
+  "Problems.UnreadableAddress": "This is not a web address — write it whole, like https://example.com",
+  "Problems.UnreadableAddressDomain": "This is not a web address — check the domain",
+  "Problems.OutOfRange": "Out of range",
+  "Problems.MaxLength": "No longer than {max} characters",
+  "Problems.NotFuture": "Cannot be later than today",
+  "Problems.NotNegative": "Cannot be below zero",
+  "Problems.NotPositive": "Cannot be above zero",
+  "Problems.PositiveAmount": "Must be above zero",
+  "Problems.NotAbove": "Cannot be greater than the upper bound",
+  "Problems.Mismatch": "The two values do not match",
+  "Problems.Invalid": "Invalid value",
+  "Problems.BadRequest": "The request could not be understood",
+
+  "Problems.Unauthorized.Title": "Authentication required",
+  "Problems.Unauthorized": "You need to sign in to do this",
+  "Problems.Forbidden.Title": "Access denied",
+  "Problems.Forbidden": "You do not have permission to do this",
+
+  "Problems.TooManyRequests.Title": "Too many requests",
+  "Problems.TooManyRequests": "Too many attempts. Wait a moment and try again",
+
+  "Problems.InternalError.Title": "An unexpected error occurred",
+  "Problems.InternalError": "Something went wrong on our side",
+  "Problems.Unknown.Title": "An unknown error occurred",
+  "Problems.Unknown": "Something went wrong",
+  "Problems.Canceled.Title": "Operation canceled",
+
+  "Problems.RequestFailed.Title": "Unable to contact the server",
+  "Problems.NoResponse": "The server did not respond",
+  "Problems.HttpStatus": "The server responded with an error",
+  "Problems.EmptyResponse": "The server sent an empty response",
+  "Problems.DeserializationFailed": "The server response could not be read",
+  "Problems.StatusFallback": "",
+
+  "Mud.MudDataGridPager_RowsPerPage": "Rows per page:",
+  "Mud.MudDataGridPager_InfoFormat": "{0}-{1} of {2}",
+  "Mud.MudDataGridPager_AllItems": "All",
+  "Mud.MudTablePager_FirstPage": "First page",
+  "Mud.MudTablePager_PreviousPage": "Previous page",
+  "Mud.MudTablePager_NextPage": "Next page",
+  "Mud.MudTablePager_LastPage": "Last page",
+  "Mud.MudTable_Loading": "Loading...",
+  "Mud.MudTreeView_ExpandItem": "Expand",
+  "Mud.MudTreeView_CollapseItem": "Collapse",
+  "Mud.MudNavGroup_ToggleExpand": "Toggle",
+  "Mud.MudInput_Clear": "Clear",
+  "Mud.MudSnackbar_Close": "Close",
+  "Mud.MudAlert_Close": "Close",
+  "Mud.MudDialog_Close": "Close",
+  "Mud.MudChip_Close": "Remove",
+  "Mud.MudBaseDatePicker_Open": "Open calendar",
+  "Mud.MudBaseDatePicker_PrevMonth": "Previous month",
+  "Mud.MudBaseDatePicker_NextMonth": "Next month",
+  "Mud.MudBaseDatePicker_PrevYear": "Previous year",
+  "Mud.MudBaseDatePicker_NextYear": "Next year",
+  "Mud.MudTimePicker_Open": "Open clock",
+  "Common.NoRecords": "No records to show",
+  "Common.TimeGridHiddenDay": "Showing {day} — 1 more day this week is hidden to fit",
+  "Common.TimeGridHiddenDay.Plural": "Showing {day} — {count} more days this week are hidden to fit",
+
+  "Problems.Timeout.Title": "The operation took too long",
+  "Problems.Timeout": "The operation took too long to complete",
+  "Problems.ExternalTimeout.Title": "A service took too long to respond",
+  "Problems.ExternalServiceUnavailable.Title": "A service is unavailable",
+
+  "Common.Resource": "Resource"
+}

package/dist/context.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+import type { Mediator } from "./mediator";
+import { Strings } from "./strings";
+export interface StackProviderProps {
+    mediator: Mediator;
+    strings: Strings;
+    children: ReactNode;
+}
+/** What every hook of the stack reads: the mediator that sends and the strings that speak. */
+export declare function StackProvider({ mediator, strings, children }: StackProviderProps): import("react").JSX.Element;
+export interface Catalog {
+    strings: Strings | null;
+    failed: boolean;
+}
+/** The catalog for a language: the Stack's sentences with the app's merged over them — the app's
+ * keys win, as an app's strings registered last win on the server. A failed read still yields
+ * the Stack's own, so the page renders keyed rather than blank. */
+export declare function useCatalog(language: string, load?: (language: string) => Promise<Record<string, string>>): Catalog;
+export declare function useMediator(): Mediator;
+export declare function useStrings(): Strings;

package/dist/context.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+import { createContext, useContext, useEffect, useState } from "react";
+import { Strings, stackStrings } from "./strings";
+const MediatorContext = createContext(null);
+const StringsContext = createContext(null);
+/** What every hook of the stack reads: the mediator that sends and the strings that speak. */
+export function StackProvider({ mediator, strings, children }) {
+    return (_jsx(MediatorContext.Provider, { value: mediator, children: _jsx(StringsContext.Provider, { value: strings, children: children }) }));
+}
+/** The catalog for a language: the Stack's sentences with the app's merged over them — the app's
+ * keys win, as an app's strings registered last win on the server. A failed read still yields
+ * the Stack's own, so the page renders keyed rather than blank. */
+export function useCatalog(language, load) {
+    const [catalog, setCatalog] = useState({ strings: null, failed: false });
+    useEffect(() => {
+        let live = true;
+        (load ? load(language) : Promise.resolve({}))
+            .then((entries) => {
+            if (live) {
+                document.documentElement.lang = language;
+                setCatalog({ strings: new Strings(language, { ...stackStrings(language), ...entries }), failed: false });
+            }
+        })
+            .catch(() => {
+            if (live) {
+                setCatalog({ strings: new Strings(language, stackStrings(language)), failed: true });
+            }
+        });
+        return () => {
+            live = false;
+        };
+    }, [language, load]);
+    return catalog;
+}
+export function useMediator() {
+    const mediator = useContext(MediatorContext);
+    if (!mediator) {
+        throw new Error("useMediator needs a <StackProvider> above it.");
+    }
+    return mediator;
+}
+export function useStrings() {
+    const strings = useContext(StringsContext);
+    if (!strings) {
+        throw new Error("useStrings needs a <StackProvider> above it.");
+    }
+    return strings;
+}

package/dist/descriptors.d.ts

@@ -0,0 +1,52 @@
+export type FieldKind = "string" | "guid" | "boolean" | "integer" | "number" | "date" | "datetime" | "time" | "duration" | "enum" | "array" | "map" | "object" | "unknown";
+export type Binding = "route" | "query" | "header" | "body";
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+export interface EnumType<TValue extends string = string> {
+    readonly key: string;
+    readonly values: readonly TValue[];
+}
+/** What the generator knows about one member: its wire kind, its localization key, how it
+ * binds and which of the message's DataAnnotations it carries. */
+export interface Field {
+    readonly kind: FieldKind;
+    readonly key: string;
+    readonly nullable?: true;
+    readonly enum?: EnumType;
+    readonly element?: FieldKind;
+    readonly binding?: Binding;
+    readonly required?: true;
+    readonly maxLength?: number;
+    readonly minLength?: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly format?: "email" | "phone" | "url";
+    readonly pattern?: string;
+    /** Validation attributes only the server judges — a coded rule, or one the generator could
+     * not construct — named without their "Attribute" suffix. */
+    readonly serverRules?: readonly string[];
+}
+export type Fields<T> = {
+    readonly [K in keyof T]-?: Field;
+};
+export interface MessageType<TRequest, TResult> {
+    readonly name: string;
+    readonly key: string;
+    readonly area: string | null;
+    readonly method: Method;
+    readonly path: string;
+    readonly fields: Fields<TRequest>;
+    /** Never set: carries the result type so send() can infer it. */
+    readonly __result?: TResult;
+}
+export interface ModelType<T> {
+    readonly key: string;
+    readonly fields: Fields<T>;
+}
+export type RequestOf<M> = M extends MessageType<infer TRequest, unknown> ? TRequest : never;
+export type ResultOf<M> = M extends MessageType<unknown, infer TResult> ? TResult : never;
+export declare function defineEnum<TValue extends string>(key: string, values: readonly TValue[]): EnumType<TValue>;
+export declare function defineModel<T>(key: string, fields: Fields<T>): ModelType<T>;
+export declare function defineMessage<TRequest, TResult>(descriptor: Omit<MessageType<TRequest, TResult>, "__result">): MessageType<TRequest, TResult>;
+/** The C# member a field was generated from — the last segment of its key, which is what a
+ * server Issue names in its source. */
+export declare function memberOf(field: Field): string;

package/dist/descriptors.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+export function defineEnum(key, values) {
+    return { key, values };
+}
+export function defineModel(key, fields) {
+    return { key, fields };
+}
+export function defineMessage(descriptor) {
+    return descriptor;
+}
+/** The C# member a field was generated from — the last segment of its key, which is what a
+ * server Issue names in its source. */
+export function memberOf(field) {
+    return field.key.slice(field.key.lastIndexOf(".") + 1);
+}

package/dist/form.d.ts

@@ -0,0 +1,18 @@
+import { type MessageType } from "./descriptors";
+import type { Issue, Problem } from "./problems";
+export interface Form<T> {
+    readonly message: MessageType<T, unknown>;
+    readonly value: T;
+    readonly submitting: boolean;
+    /** The last send landed and nothing changed since. */
+    readonly saved: boolean;
+    /** What the server last refused, kept until the field it is about changes. */
+    readonly problem: Problem | null;
+    set<K extends keyof T>(name: K, value: T[K]): void;
+    reset(value: T): void;
+    issues(name: keyof T): Issue[];
+    submit(action: (value: T) => Promise<void>): Promise<boolean>;
+}
+/** The state of one message being filled in: its value, its refusals (the descriptor's rules
+ * checked as the user types, the server's answer after a send) and whether a send is running. */
+export declare function useForm<T>(message: MessageType<T, unknown>, initial: T): Form<T>;

package/dist/form.js

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+import { useCallback, useMemo, useState } from "react";
+import { memberOf } from "./descriptors";
+import { validate, validateField } from "./validation";
+import { problemOf } from "./load";
+/** The state of one message being filled in: its value, its refusals (the descriptor's rules
+ * checked as the user types, the server's answer after a send) and whether a send is running. */
+export function useForm(message, initial) {
+    const [value, setValue] = useState(initial);
+    const [touched, setTouched] = useState(new Set());
+    const [problem, setProblem] = useState(null);
+    const [submitting, setSubmitting] = useState(false);
+    const [saved, setSaved] = useState(false);
+    const set = useCallback((name, next) => {
+        setValue((current) => ({ ...current, [name]: next }));
+        setTouched((current) => new Set(current).add(name));
+        setSaved(false);
+        const member = memberOf(message.fields[name]);
+        setProblem((current) => (current ? { ...current, issues: current.issues.filter((issue) => issue.source !== member) } : current));
+    }, [message]);
+    const reset = useCallback((next) => {
+        setValue(next);
+        setTouched(new Set());
+        setProblem(null);
+    }, []);
+    const issues = useCallback((name) => {
+        const field = message.fields[name];
+        const member = memberOf(field);
+        const local = touched.has(name) ? validateField(field, value[name]) : [];
+        const remote = problem?.issues.filter((issue) => issue.source === member) ?? [];
+        return [...local, ...remote.filter((r) => !local.some((l) => l.code === r.code))];
+    }, [message, touched, value, problem]);
+    const submit = useCallback(async (action) => {
+        const refused = validate(message, value);
+        if (refused) {
+            setTouched(new Set(Object.keys(message.fields)));
+            setProblem(refused);
+            return false;
+        }
+        setSubmitting(true);
+        setSaved(false);
+        setProblem(null);
+        try {
+            await action(value);
+            setSaved(true);
+            return true;
+        }
+        catch (error) {
+            setProblem(problemOf(error));
+            return false;
+        }
+        finally {
+            setSubmitting(false);
+        }
+    }, [message, value]);
+    return useMemo(() => ({ message, value, submitting, saved, problem, set, reset, issues, submit }), [message, value, submitting, saved, problem, set, reset, issues, submit]);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./descriptors";
+export * from "./problems";
+export * from "./validation";
+export * from "./mediator";
+export * from "./strings";
+export * from "./context";
+export * from "./load";
+export * from "./form";

package/dist/index.js

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+export * from "./descriptors";
+export * from "./problems";
+export * from "./validation";
+export * from "./mediator";
+export * from "./strings";
+export * from "./context";
+export * from "./load";
+export * from "./form";

package/dist/load.d.ts

@@ -0,0 +1,22 @@
+import type { MessageType } from "./descriptors";
+import { type Problem } from "./problems";
+export type Load<T> = {
+    state: "loading";
+    data: T | undefined;
+    problem: null;
+    reload: () => void;
+} | {
+    state: "loaded";
+    data: T;
+    problem: null;
+    reload: () => void;
+} | {
+    state: "failed";
+    data: T | undefined;
+    problem: Problem;
+    reload: () => void;
+};
+export declare function problemOf(error: unknown): Problem;
+/** Reads a query and keeps it current: the request is compared by value, so a new object with
+ * the same filters does not read twice, and an answer that lost the race is dropped. */
+export declare function useLoad<TRequest, TResult>(message: MessageType<TRequest, TResult>, request: TRequest): Load<TResult>;

package/dist/load.js

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+import { useCallback, useEffect, useRef, useState } from "react";
+import { BusinessError, requestFailed } from "./problems";
+import { useMediator } from "./context";
+export function problemOf(error) {
+    return error instanceof BusinessError ? error.problem : requestFailed(null, null);
+}
+/** Reads a query and keeps it current: the request is compared by value, so a new object with
+ * the same filters does not read twice, and an answer that lost the race is dropped. */
+export function useLoad(message, request) {
+    const mediator = useMediator();
+    const identity = JSON.stringify(request);
+    const [version, setVersion] = useState(0);
+    const [load, setLoad] = useState({
+        state: "loading",
+        data: undefined,
+        problem: null,
+    });
+    const latest = useRef(request);
+    latest.current = request;
+    useEffect(() => {
+        const abort = new AbortController();
+        setLoad((current) => ({ state: "loading", data: current.data, problem: null }));
+        mediator
+            .send(message, latest.current, { signal: abort.signal })
+            .then((data) => setLoad({ state: "loaded", data, problem: null }))
+            .catch((error) => {
+            if (!abort.signal.aborted) {
+                setLoad((current) => ({ state: "failed", data: current.data, problem: problemOf(error) }));
+            }
+        });
+        return () => abort.abort();
+    }, [mediator, message, identity, version]);
+    const reload = useCallback(() => setVersion((v) => v + 1), []);
+    return { ...load, reload };
+}

package/dist/mediator.d.ts

@@ -0,0 +1,23 @@
+import type { MessageType } from "./descriptors";
+export interface MediatorOptions {
+    /** Origin the API lives at; empty means the host that served the page. */
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    /** Headers every send carries (a language, a tenant). Read per send. */
+    headers?: () => Record<string, string>;
+}
+export interface SendOptions {
+    signal?: AbortSignal;
+}
+/** Sends a message to the endpoint its [Http] declares: the client half of HttpSender. The
+ * request's own DataAnnotations are checked before anything leaves, as SendPipeline does. */
+export declare class Mediator {
+    #private;
+    constructor(options?: MediatorOptions);
+    send<TRequest, TResult>(message: MessageType<TRequest, TResult>, request: TRequest, options?: SendOptions): Promise<TResult>;
+    url<TRequest>(message: MessageType<TRequest, unknown>, request: TRequest): string;
+    private hasBody;
+    private bodyOf;
+    private headersOf;
+    private problemOf;
+}

package/dist/mediator.js

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+import { BusinessError, isProblem, requestFailed } from "./problems";
+import { validate } from "./validation";
+function format(value) {
+    return typeof value === "string" ? value : String(value);
+}
+/** Sends a message to the endpoint its [Http] declares: the client half of HttpSender. The
+ * request's own DataAnnotations are checked before anything leaves, as SendPipeline does. */
+export class Mediator {
+    #baseUrl;
+    #fetch;
+    #headers;
+    constructor(options = {}) {
+        this.#baseUrl = (options.baseUrl ?? "").replace(/\/+$/, "");
+        this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.#headers = options.headers ?? (() => ({}));
+    }
+    async send(message, request, options = {}) {
+        const refused = validate(message, request);
+        if (refused) {
+            throw new BusinessError(refused);
+        }
+        let response;
+        try {
+            response = await this.#fetch(this.url(message, request), {
+                method: message.method,
+                headers: { Accept: "application/json", ...this.#headers(), ...this.headersOf(message, request), ...(this.hasBody(message) ? { "Content-Type": "application/json" } : {}) },
+                body: this.hasBody(message) ? JSON.stringify(this.bodyOf(message, request)) : undefined,
+                signal: options.signal,
+            });
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError") {
+                throw error;
+            }
+            throw new BusinessError(requestFailed(null, null));
+        }
+        const text = await response.text();
+        if (!response.ok) {
+            throw new BusinessError(this.problemOf(response.status, text));
+        }
+        if (text.length === 0) {
+            return undefined;
+        }
+        return JSON.parse(text);
+    }
+    url(message, request) {
+        const values = request;
+        const fields = Object.entries(message.fields);
+        const path = message.path.replace(/{([^{}:?]+)[^{}]*}/g, (_, token) => {
+            const name = fields.find(([candidate]) => candidate.toLowerCase() === token.toLowerCase())?.[0] ?? token;
+            return encodeURIComponent(format(values[name]));
+        });
+        const query = new URLSearchParams();
+        for (const [name, field] of fields) {
+            const value = values[name];
+            // An unset filter is an absent parameter, never "null" (HttpRequestMessageBuilder.AddQuery).
+            if (field.binding !== "query" || value === null || value === undefined) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                value.filter((item) => item !== null && item !== undefined).forEach((item) => query.append(name, format(item)));
+            }
+            else {
+                query.append(name, format(value));
+            }
+        }
+        const search = query.toString();
+        return `${this.#baseUrl}/${path}${search ? `?${search}` : ""}`;
+    }
+    hasBody(message) {
+        return message.method === "POST" || message.method === "PUT" || message.method === "PATCH";
+    }
+    bodyOf(message, request) {
+        const values = request;
+        const body = {};
+        for (const [name, field] of Object.entries(message.fields)) {
+            if (field.binding === "body" && values[name] !== undefined) {
+                body[name] = values[name];
+            }
+        }
+        return body;
+    }
+    headersOf(message, request) {
+        const values = request;
+        const headers = {};
+        for (const [name, field] of Object.entries(message.fields)) {
+            if (field.binding === "header" && values[name] !== null && values[name] !== undefined) {
+                headers[name] = format(values[name]);
+            }
+        }
+        return headers;
+    }
+    problemOf(status, text) {
+        if (text.length === 0) {
+            return requestFailed(status, "EmptyResponse");
+        }
+        try {
+            const parsed = JSON.parse(text);
+            return isProblem(parsed) ? { ...parsed, issues: parsed.issues ?? [] } : requestFailed(status, "StatusFallback");
+        }
+        catch {
+            return requestFailed(status, "DeserializationFailed");
+        }
+    }
+}

package/dist/problems.d.ts

@@ -0,0 +1,23 @@
+export interface Issue {
+    code: string;
+    message: string;
+    source?: string | null;
+    arguments?: Record<string, string> | null;
+}
+export interface Problem {
+    code: string;
+    title: string;
+    issues: Issue[];
+    status?: number | null;
+}
+/** The TypeScript face of BusinessException: an expected failure carrying the Problem the
+ * server (or the client's own validation) answered. */
+export declare class BusinessError extends Error {
+    readonly problem: Problem;
+    constructor(problem: Problem);
+}
+export declare function isProblem(value: unknown): value is Problem;
+/** The same codes NetworkProblem.RequestFailed carries, so one catalog translates both ends. */
+export declare function requestFailed(status: number | null, reason: "EmptyResponse" | "DeserializationFailed" | "StatusFallback" | null): Problem;
+/** Issues about one field, matched by the C# member name a server Issue names in its source. */
+export declare function issuesFor(problem: Problem | null | undefined, member: string): Issue[];

package/dist/problems.js

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+/** The TypeScript face of BusinessException: an expected failure carrying the Problem the
+ * server (or the client's own validation) answered. */
+export class BusinessError extends Error {
+    problem;
+    constructor(problem) {
+        super(problem.title);
+        this.name = "BusinessError";
+        this.problem = problem;
+    }
+}
+export function isProblem(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.code === "string" &&
+        typeof value.title === "string");
+}
+/** The same codes NetworkProblem.RequestFailed carries, so one catalog translates both ends. */
+export function requestFailed(status, reason) {
+    const issues = [
+        status
+            ? { code: "HttpStatus", message: `The server responded with HTTP status code ${status}.` }
+            : { code: "NoResponse", message: "No response was received from the server." },
+    ];
+    if (reason) {
+        issues.push({ code: reason, message: reason });
+    }
+    return { code: "RequestFailed", title: "Unable to contact the server", issues, status };
+}
+/** Issues about one field, matched by the C# member name a server Issue names in its source. */
+export function issuesFor(problem, member) {
+    if (!problem) {
+        return [];
+    }
+    return problem.issues.filter((issue) => issue.source === member);
+}

package/dist/strings.d.ts

@@ -0,0 +1,19 @@
+import type { EnumType } from "./descriptors";
+import type { Issue, Problem } from "./problems";
+export declare function stackStrings(language: string): Record<string, string>;
+/** StringManager, for the browser: a missing key renders as the key itself (or the fallback
+ * given), so an untranslated string is visible instead of guessed. */
+export declare class Strings {
+    #private;
+    readonly language: string;
+    constructor(language: string, entries: Record<string, string>);
+    translate(key: string, fallback?: string): string;
+    /** Named ({name}) or positional ({0}) tokens filled from the arguments. */
+    format(key: string, args: Record<string, string> | readonly string[]): string;
+    count(key: string, count: number): string;
+    enumValue(type: EnumType, value: string | null | undefined): string;
+    /** "Problems.{Code}.{Source}", then "Problems.{Code}", then the message the sender wrote; the
+     * entity argument is a key and resolves to its label first. */
+    issue(issue: Issue): string;
+    problem(problem: Problem): string;
+}

package/dist/strings.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+import mudBase from "./catalogs/strings.json";
+import mudEs from "./catalogs/strings.es.json";
+// The Stack's own sentences (Common.*, Actions.*, Problems.*) are the Blazor components'
+// catalog, read from the very files NSail.Components.Mud embeds: one string in one file, whichever
+// renderer draws it.
+const stackCatalogs = { en: mudBase, es: { ...mudBase, ...mudEs } };
+export function stackStrings(language) {
+    return stackCatalogs[language] ?? stackCatalogs.en;
+}
+const token = /{([A-Za-z0-9_]+)}/g;
+function fill(text, args) {
+    if (!args) {
+        return text;
+    }
+    return text.replace(token, (whole, name) => (name in args ? args[name] : whole));
+}
+/** StringManager, for the browser: a missing key renders as the key itself (or the fallback
+ * given), so an untranslated string is visible instead of guessed. */
+export class Strings {
+    language;
+    #entries;
+    constructor(language, entries) {
+        this.language = language;
+        this.#entries = entries;
+    }
+    translate(key, fallback) {
+        return this.#entries[key] ?? fallback ?? key;
+    }
+    /** Named ({name}) or positional ({0}) tokens filled from the arguments. */
+    format(key, args) {
+        const named = Array.isArray(args) ? Object.fromEntries(args.map((value, index) => [String(index), value])) : args;
+        return fill(this.translate(key), named);
+    }
+    count(key, count) {
+        const plural = count !== 1 ? this.#entries[`${key}.Plural`] : undefined;
+        return fill(plural ?? this.translate(key), { "0": String(count), count: String(count) });
+    }
+    enumValue(type, value) {
+        if (value === null || value === undefined) {
+            return "";
+        }
+        return this.translate(`${type.key}.${value}`, value);
+    }
+    /** "Problems.{Code}.{Source}", then "Problems.{Code}", then the message the sender wrote; the
+     * entity argument is a key and resolves to its label first. */
+    issue(issue) {
+        const scoped = issue.source ? this.#entries[`Problems.${issue.code}.${issue.source}`] : undefined;
+        const text = scoped ?? this.#entries[`Problems.${issue.code}`] ?? issue.message;
+        const args = issue.arguments ? { ...issue.arguments } : null;
+        if (args?.entity) {
+            args.entity = this.translate(args.entity, args.entity.slice(args.entity.lastIndexOf(".") + 1));
+        }
+        return fill(text, args);
+    }
+    problem(problem) {
+        return this.translate(`Problems.${problem.code}.Title`, problem.title);
+    }
+}

package/dist/validation.d.ts

@@ -0,0 +1,6 @@
+import { type Field, type MessageType } from "./descriptors";
+import type { Issue, Problem } from "./problems";
+export declare function validateField(field: Field, value: unknown): Issue[];
+/** The problem describing every rule the request breaks, or null — the client half of the
+ * check SendPipeline runs on both sides. */
+export declare function validate<TRequest>(message: MessageType<TRequest, unknown>, request: TRequest): Problem | null;

package/dist/validation.js

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 Leonardo Porro and Emmanuel Arias. https://github.com/nsail-ar/nsail-stack
+import { memberOf } from "./descriptors";
+// MessageValidator's vocabulary, code for code and argument for argument: the sentence under a
+// field reads the same whether the browser refused the value or the server did.
+const email = /^[^@\s]+@[^@\s]+$/;
+const phone = /^\+?(?=.*\d)[\d\s().\-]+((x|ext\.?)\s?\d+)?$/i;
+const url = /^(https?|ftp):\/\//i;
+function issue(code, message, field, args = {}) {
+    return { code, message, source: field, arguments: { field, ...args } };
+}
+function isBlank(value) {
+    return value === null || value === undefined || (typeof value === "string" && value.trim().length === 0);
+}
+function length(value) {
+    if (typeof value === "string" || Array.isArray(value)) {
+        return value.length;
+    }
+    return null;
+}
+export function validateField(field, value) {
+    const name = memberOf(field);
+    const issues = [];
+    if (field.required && isBlank(value)) {
+        issues.push(issue("Required", `The field ${name} is required`, name));
+    }
+    // Every BCL attribute but Required passes a null: absence is Required's question alone.
+    if (value === null || value === undefined) {
+        return issues;
+    }
+    const size = length(value);
+    if (field.maxLength !== undefined && size !== null && size > field.maxLength) {
+        issues.push(issue("MaxLength", `The field ${name} exceeds the maximum length of ${field.maxLength}`, name, { max: String(field.maxLength) }));
+    }
+    if (field.minLength !== undefined && size !== null && size < field.minLength) {
+        issues.push(issue("Invalid", `The field ${name} must have at least ${field.minLength} characters`, name));
+    }
+    if ((field.min !== undefined || field.max !== undefined) && typeof value === "number") {
+        if ((field.min !== undefined && value < field.min) || (field.max !== undefined && value > field.max)) {
+            issues.push(issue("OutOfRange", `The field ${name} must be between ${field.min} and ${field.max}`, name, { from: String(field.min), to: String(field.max) }));
+        }
+    }
+    if (typeof value === "string" && value.length > 0) {
+        const formatted = (field.format === "email" && !email.test(value)) ||
+            (field.format === "phone" && !phone.test(value)) ||
+            (field.format === "url" && !url.test(value)) ||
+            (field.pattern !== undefined && !new RegExp(`^(?:${field.pattern})$`).test(value));
+        if (formatted) {
+            issues.push(issue("InvalidFormat", `The field ${name} has an invalid format`, name));
+        }
+    }
+    return issues;
+}
+/** The problem describing every rule the request breaks, or null — the client half of the
+ * check SendPipeline runs on both sides. */
+export function validate(message, request) {
+    const issues = [];
+    const values = request;
+    for (const [name, field] of Object.entries(message.fields)) {
+        issues.push(...validateField(field, values[name]));
+    }
+    if (issues.length === 0) {
+        return null;
+    }
+    return { code: "InvalidModel", title: "One or more fields contain invalid data", issues, status: 400 };
+}

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@nsail/stack",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.135",
+  "description": "NSail's vendor-free client half: sends messages from the descriptors an Sdk generates, speaks the catalog, and holds the hooks a page reads with.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nsail-ar/nsail-stack.git",
+    "directory": "src/Stack/React/NSail.React.Stack"
+  },
+  "homepage": "https://github.com/nsail-ar/nsail-stack#readme",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "@nsail/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": ">=19"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.