@asteby/metacore-runtime-react 46.3.0 → 47.0.0

package/src/dynamic-table.tsx

@@ -66,6 +66,7 @@ import { Inbox, Download, Upload, Trash2 } from 'lucide-react'
 import { toast } from 'sonner'
 import { Progress } from './dialogs/_primitives'
 import { useMetadataCache } from './metadata-cache'
+import { useRecordMutationTick } from './use-record-mutation-tick'
 import { useApi, useCurrentBranch } from './api-context'
 import { useReasonPrompt } from './reason-prompt'
 import type { ColumnFilterConfig, GetDynamicColumns } from './dynamic-columns-shim'
@@ -295,6 +296,9 @@ export function DynamicTable({
     // OrgRuntimeProvider (without it, money fell back to USD).
     const orgTimeZone = useTimeZone()
     const orgCurrency = useCurrency()
+    // Bumps when a dialog/modal anywhere creates, edits or deletes a record of
+    // this model, so the list reloads without the caller wiring refreshTrigger.
+    const mutationTick = useRecordMutationTick(model)
     const timeZone = timeZoneProp ?? orgTimeZone
     const currency = currencyProp ?? orgCurrency
     // The explicit `pagination` prop wins; the legacy `infiniteScroll` boolean
@@ -917,7 +921,7 @@ export function DynamicTable({
         } finally {
             setLoadingData(false)
         }
-    }, [model, metadata, pagination, buildFilterParams, refreshTrigger, endpoint, currentBranch?.id, api, enableUrlSync, relationInclude])
+    }, [model, metadata, pagination, buildFilterParams, refreshTrigger, mutationTick, endpoint, currentBranch?.id, api, enableUrlSync, relationInclude])
 
     // Columns whose metadata opts into a footer total (display_config.aggregate
     // → styleConfig.aggregate). When empty, no footer row is rendered and no
@@ -1098,7 +1102,7 @@ export function DynamicTable({
         // deps). Without it the comment above lied: infinite lists silently
         // failed to reload after a create ("a veces no recarga la tabla").
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [infiniteScroll, metadata, filterSignature, refreshTrigger])
+    }, [infiniteScroll, metadata, filterSignature, refreshTrigger, mutationTick])
 
     const handleRefresh = useCallback(() => {
         // Infinite mode owns its own list: refresh reloads page 1 and drops the

package/src/index.ts

@@ -188,6 +188,42 @@ export {
     type ModelActionToolbarProps,
     type ActionPlacement,
 } from './model-action-toolbar'
+export {
+    resolveListPrimaryAction,
+    actionReplacesCreate,
+    type ListPrimaryActionInput,
+    type ListPrimaryActionResult,
+    type ListActionRef,
+    type CreateMode,
+} from './list-primary-action'
+export {
+    emitRecordMutation,
+    subscribeRecordMutations,
+    RECORD_MUTATION_EVENT,
+    type RecordMutationKind,
+    type RecordMutationDetail,
+} from './record-mutation-events'
+export {
+    DocumentFormDialog,
+    resolveDocumentForms,
+    type DocumentFormDialogProps,
+} from './document-form-dialog'
+export {
+    modelFromNavUrl,
+    capabilityForNavItem,
+    isNavItemAllowed,
+    useNavItemVisible,
+    type NavLeafLike,
+} from './nav-permissions'
+export {
+    CfdiStampPanel,
+    CfdiStampResultDialog,
+    extractStampResult,
+    type CfdiStampResult,
+    type CfdiStampPanelProps,
+    type CfdiStampResultDialogProps,
+} from './cfdi-stamp-panel'
+export { useRecordMutationTick } from './use-record-mutation-tick'
 export * from './addon-loader'
 export {
     PURGE_ADDON_MESSAGE,

package/src/list-primary-action.ts

@@ -0,0 +1,71 @@
+// Una sola acción primaria de alta por pantalla (UX-1).
+// Puro: DynamicCRUDPage y ModelActionToolbar lo usan, y el shell de ops
+// (`/m/$model`) debe llamarlo también para no pintar un segundo «Crear».
+
+export type CreateMode = 'generic' | 'hidden' | 'action'
+
+export interface ListActionRef {
+    key: string
+    placement?: string
+    /** El kernel sirve snake_case. CamelCase se acepta por si el host ya lo normalizó. */
+    replaces_create?: boolean
+    replacesCreate?: boolean
+}
+
+export interface ListPrimaryActionInput {
+    /** `metadata.enableCRUDActions`. Sin él no hay Crear genérico. */
+    enableCRUD?: boolean
+    /** `metadata.canCreate`. `false` oculta el genérico; `undefined` no cambia nada. */
+    canCreate?: boolean
+    hideCreate?: boolean
+    createMode?: CreateMode
+    /** Si apunta a una acción de toolbar, esa es la primaria y oculta el genérico. */
+    primaryActionKey?: string
+    actions?: ListActionRef[]
+}
+
+export interface ListPrimaryActionResult {
+    showGenericCreate: boolean
+    primaryAction?: ListActionRef
+    /** Acciones de toolbar que no son la primaria (siguen visibles, en secundario). */
+    secondaryActions: ListActionRef[]
+    /** Más de una acción reclama ser la primaria. Solo una se usa. */
+    conflict: boolean
+}
+
+/** `placement: create`, o el flag declarativo para una acción que hoy es `table`. */
+export function actionReplacesCreate(action: ListActionRef): boolean {
+    return action.placement === 'create' || action.replaces_create === true || action.replacesCreate === true
+}
+
+function isToolbar(action: ListActionRef): boolean {
+    const placement = action.placement ?? 'row'
+    return placement === 'table' || placement === 'create' || actionReplacesCreate(action)
+}
+
+export function resolveListPrimaryAction(input: ListPrimaryActionInput): ListPrimaryActionResult {
+    const actions = input.actions ?? []
+    const claimants = actions.filter(actionReplacesCreate)
+
+    let primary: ListActionRef | undefined
+    if (input.primaryActionKey) {
+        const keyed = actions.find((a) => a.key === input.primaryActionKey)
+        if (keyed && isToolbar(keyed)) primary = keyed
+    }
+    if (!primary && claimants.length > 0) primary = claimants[0]
+
+    const hideGeneric =
+        input.hideCreate === true ||
+        input.canCreate === false ||
+        input.createMode === 'hidden' ||
+        input.createMode === 'action' ||
+        input.enableCRUD !== true ||
+        primary != null
+
+    return {
+        showGenericCreate: !hideGeneric,
+        primaryAction: primary,
+        secondaryActions: actions.filter((a) => isToolbar(a) && a.key !== primary?.key),
+        conflict: claimants.length > 1,
+    }
+}

package/src/model-action-toolbar.tsx

@@ -32,6 +32,7 @@ import {
     useRequiresAddonLabel,
 } from './requires-addon'
 import type { ActionDefinition, ActionMetadata, RequiresAddon, TableMetadata } from './types'
+import { resolveListPrimaryAction } from './list-primary-action'
 
 export type ActionPlacement = 'row' | 'table' | 'create'
 
@@ -58,6 +59,12 @@ export interface ModelActionToolbarProps {
      * lazy load without blocking first paint of the list page.
      */
     onActionIntent?: (action: ActionDefinition) => void
+    /**
+     * Acción que queda como único botón primario (`data-primary`). El resto de
+     * las que reclaman el alta bajan a `outline`. Lo resuelve igual
+     * `resolveListPrimaryAction`.
+     */
+    primaryActionKey?: string
 }
 
 const DEFAULT_PLACEMENTS: ActionPlacement[] = ['table', 'create']
@@ -139,6 +146,7 @@ export function ModelActionToolbar({
     onChange,
     className,
     onActionIntent,
+    primaryActionKey,
 }: ModelActionToolbarProps) {
     const { t } = useTranslation()
     const all = useModelActions(model, placements, actions)
@@ -153,6 +161,11 @@ export function ModelActionToolbar({
     const [missingAddon, setMissingAddon] = useState<RequiresAddon | null>(null)
     const requiresAddonLabel = useRequiresAddonLabel()
     const dataEndpoint = endpoint ?? `/data/${model}/me`
+    const primary = resolveListPrimaryAction({
+        enableCRUD: true,
+        primaryActionKey,
+        actions: surfaced,
+    })
 
     if (surfaced.length === 0) return null
 
@@ -160,16 +173,18 @@ export function ModelActionToolbar({
         <>
             <div className={className ?? 'flex items-center gap-2'}>
                 {surfaced.map((a) => {
-                    const isCreate = (a.placement ?? 'row') === 'create'
+                    const isPrimary = primary.primaryAction?.key === a.key
+                    const isCreate = isPrimary || (a.placement ?? 'row') === 'create'
                     // Locked while its optional addon is missing: still shown,
                     // but a click explains + offers install instead of running.
                     const requirement = resolveRequiresAddon(a)
                     return (
                         <Button
                             key={a.key}
-                            variant={isCreate ? 'default' : 'outline'}
+                            variant={isPrimary ? 'default' : 'outline'}
+                            data-primary={isPrimary ? 'true' : undefined}
                             data-aby-target={
-                                isCreate
+                                isPrimary
                                     ? `model.${model}.create`
                                     : `model.${model}.action.${a.key}`
                             }

package/src/model-extension-registry.tsx

@@ -24,6 +24,13 @@ export interface ModelExtension {
     headerExtras?: React.ComponentType<ModelExtensionProps>
     toolbarExtras?: React.ComponentType<ModelExtensionProps>
     hideCreate?: boolean
+    /**
+     * `hidden` quita el Crear genérico. `action` también, porque la acción del
+     * módulo (ver `primaryActionKey`) es la alta. `generic` lo deja.
+     */
+    createMode?: 'generic' | 'hidden' | 'action'
+    /** Acción de toolbar que queda como único botón primario y oculta el Crear genérico. */
+    primaryActionKey?: string
     hideExport?: boolean
     hideImport?: boolean
     hideRefresh?: boolean

package/src/nav-permissions.ts

@@ -0,0 +1,58 @@
+// nav-permissions — the sidebar follows the role's EFFECTIVE permissions
+// (PIT-044). Before, every installed addon's entries were listed for every
+// role and only failed with a 403 after the click.
+//
+// Rules (same capability vocabulary as useCan/gateTableMetadata):
+//   - no <PermissionsProvider> mounted, or isAdmin / "*"  -> nothing hidden
+//     (useCan() is always-true then, so the predicate is a no-op);
+//   - an entry with an explicit `requires` capability     -> can(requires);
+//   - an entry pointing at a model screen (`/m/<model>`)  -> can('<model>.index');
+//   - any other entry (custom pages, activity, settings…) -> kept. Those are
+//     gated by the backend / the host's own `requires`, never guessed here.
+import { useCallback } from 'react'
+import { modelCapability, useCan, usePermissionsActive, type CanFn } from './permissions-context'
+
+/** Minimal structural shape of a sidebar leaf (matches `@asteby/metacore-ui` NavLinkItem). */
+export interface NavLeafLike {
+    url: string
+    requires?: string
+}
+
+const MODEL_URL_RE = /^\/(?:app\/)?m\/([^/?#]+)/i
+
+/** Model key of a `/m/<model>` url, or undefined for any other route. */
+export function modelFromNavUrl(url: string | undefined): string | undefined {
+    if (!url) return undefined
+    const m = MODEL_URL_RE.exec(url)
+    if (!m) return undefined
+    try {
+        return decodeURIComponent(m[1])
+    } catch {
+        return m[1]
+    }
+}
+
+/** Capability a leaf needs, or undefined when it is not gated by the SDK. */
+export function capabilityForNavItem(item: NavLeafLike): string | undefined {
+    if (item.requires) return item.requires
+    const model = modelFromNavUrl(item.url)
+    return model ? modelCapability(model, 'index') : undefined
+}
+
+/** Pure visibility predicate for a leaf given a capability checker. */
+export function isNavItemAllowed(item: NavLeafLike, can: CanFn): boolean {
+    const cap = capabilityForNavItem(item)
+    return cap ? can(cap) : true
+}
+
+/**
+ * Hook for the host's sidebar: returns a predicate for `<AppSidebar
+ * isItemVisible>` / `filterNavGroups`, or `undefined` when permission gating
+ * is not active (nothing to filter).
+ */
+export function useNavItemVisible(): ((item: NavLeafLike) => boolean) | undefined {
+    const can = useCan()
+    const active = usePermissionsActive()
+    const predicate = useCallback((item: NavLeafLike) => isNavItemAllowed(item, can), [can])
+    return active ? predicate : undefined
+}

package/src/navigation-builder.tsx

@@ -1,6 +1,7 @@
 // NavigationBuilder — merges a host's base sidebar with `manifest.navigation`
 // contributions from every loaded addon. Pure function + a React hook.
 import { useMemo } from 'react'
+import { useCan, type CanFn } from './permissions-context'
 
 export interface NavItem {
     key: string
@@ -59,8 +60,33 @@ export function mergeNavigation(base: NavItem[], contributions: AddonNavigationC
         .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))
 }
 
+/**
+ * Drops items whose `requires` capability the user lacks (PIT-044). A parent
+ * left without children is dropped too, unless it links somewhere itself.
+ */
+export function filterNavigationByCapability(items: NavItem[], can: CanFn): NavItem[] {
+    const out: NavItem[] = []
+    for (const item of items) {
+        if (item.requires && !can(item.requires)) continue
+        if (item.children) {
+            const children = filterNavigationByCapability(item.children, can)
+            if (children.length === 0 && item.children.length > 0 && !item.to) continue
+            out.push({ ...item, children })
+        } else {
+            out.push(item)
+        }
+    }
+    return out
+}
+
 export function useNavigation(base: NavItem[], contributions: AddonNavigationContribution[]): NavItem[] {
-    return useMemo(() => mergeNavigation(base, contributions), [base, contributions])
+    // useCan() allows everything without a <PermissionsProvider>, so hosts that
+    // never opt in keep the full tree.
+    const can = useCan()
+    return useMemo(
+        () => filterNavigationByCapability(mergeNavigation(base, contributions), can),
+        [base, contributions, can],
+    )
 }
 
 export interface NavigationBuilderProps {

package/src/permissions-manager.tsx

@@ -73,7 +73,6 @@ import {
     Popover,
     PopoverContent,
     PopoverTrigger,
-    Separator,
     Skeleton,
     Collapsible,
     CollapsibleContent,
@@ -360,6 +359,31 @@ export function suggestRoleIcon(label: string): string {
     return 'Shield'
 }
 
+/** Label of the synthetic module that hosts the general (non-model) flags. */
+export const GENERAL_MODULE_LABEL = 'Permisos generales'
+
+/**
+ * The general flags (`general.work_after_hours`, …) as a synthetic module, so
+ * they are picked from the module combobox and edited in the same two-column
+ * action grid as any module's actions (#1021). Each flag keeps its full
+ * capability key through `PermissionActionDef.capability`.
+ */
+export function generalPermissionsModule(general: GeneralPermissionDef[]): PermissionModuleDef {
+    return {
+        key: 'general',
+        label: GENERAL_MODULE_LABEL,
+        icon: 'SlidersHorizontal',
+        kind: 'model',
+        actions: general.map((g) => ({
+            key: g.key.replace(/^general\./, ''),
+            label: g.label,
+            description: g.description,
+            capability: g.key,
+            kind: 'custom',
+        })),
+    }
+}
+
 /**
  * Normalize whatever `loadModules` returned into the canonical grouped shape.
  *
@@ -613,6 +637,15 @@ export function PermissionsManager({
 
     const allModules = React.useMemo(() => (groups ? flattenGroups(groups) : []), [groups])
 
+    // What the module picker lists: the catalog groups plus a trailing synthetic
+    // group for the general flags. `allModules` / "Otorgar todo" keep using the
+    // plain catalog, so that button's scope does not change.
+    const pickerGroups = React.useMemo<ModuleGroup[] | null>(() => {
+        if (!groups) return groups
+        if (!general || general.length === 0) return groups
+        return [...groups, { title: '', modules: [generalPermissionsModule(general)] }]
+    }, [groups, general])
+
     // ---- initial load: catalog + roles in parallel -------------------------
     React.useEffect(() => {
         let cancelled = false
@@ -670,8 +703,8 @@ export function PermissionsManager({
         [roles, activeRoleId],
     )
     const activeModule = React.useMemo(
-        () => moduleAtEntry(groups, activeModuleKey)?.module ?? null,
-        [groups, activeModuleKey],
+        () => moduleAtEntry(pickerGroups, activeModuleKey)?.module ?? null,
+        [pickerGroups, activeModuleKey],
     )
 
     const dirty = baseline !== null && draft !== null && !capabilitySetsEqual(baseline, draft)
@@ -841,8 +874,8 @@ export function PermissionsManager({
     const moduleTotal = activeModule?.actions.length ?? 0
     const checksDisabled = !activeRole || !draft || loadingPerms || saving
     const activeModuleGroupTitle = React.useMemo(
-        () => moduleAtEntry(groups, activeModuleKey)?.group.title ?? '',
-        [groups, activeModuleKey],
+        () => moduleAtEntry(pickerGroups, activeModuleKey)?.group.title ?? '',
+        [pickerGroups, activeModuleKey],
     )
 
     // ---- render --------------------------------------------------------------
@@ -1052,26 +1085,6 @@ export function PermissionsManager({
                                 )}
                             </div>
 
-                            {(general?.length ?? 0) > 0 && (
-                                <>
-                                    <Separator />
-                                    <div>
-                                        <h3 className="mb-2 text-sm font-semibold">Permisos Generales</h3>
-                                        <div className="flex flex-col gap-2">
-                                            {general!.map((g) => (
-                                                <CapabilityCheck
-                                                    key={g.key}
-                                                    checked={draft?.has(g.key) ?? false}
-                                                    disabled={checksDisabled}
-                                                    onToggle={() => toggleCapability(g.key)}
-                                                    label={g.label}
-                                                    description={g.description}
-                                                />
-                                            ))}
-                                        </div>
-                                    </div>
-                                </>
-                            )}
                         </CardContent>
                     </Card>
 
@@ -1122,7 +1135,7 @@ export function PermissionsManager({
                                         <CommandInput placeholder="Buscar módulo…" />
                                         <CommandList className="max-h-[360px]">
                                             <CommandEmpty>Sin módulos.</CommandEmpty>
-                                            {(groups ?? []).map((group, gi) => (
+                                            {(pickerGroups ?? []).map((group, gi) => (
                                                 <CommandGroup
                                                     key={group.title || `__untitled_${gi}`}
                                                     heading={group.title || undefined}

package/src/print-document-button.tsx

@@ -51,7 +51,15 @@ export function PrintDocumentButton({
             if (e.defaultPrevented) return
             setBusy(true)
             try {
-                await printDocument({ model, id, key: documentKey, mode, filename })
+                // A caller that handles errors itself keeps ownership of the error toast.
+                await printDocument({
+                    model,
+                    id,
+                    key: documentKey,
+                    mode,
+                    filename,
+                    feedback: onError ? { progress: true, success: true, error: false } : true,
+                })
             } catch (err) {
                 onError?.(err)
             } finally {

package/src/record-mutation-events.ts

@@ -0,0 +1,50 @@
+// record-mutation-events — a tiny window-level bus that tells every mounted
+// list (DynamicTable, DynamicKanban) "a record of model X just changed".
+//
+// Why: the lists only reloaded when the *caller* bumped `refreshTrigger`. A
+// create/edit/delete done from a dialog the shell opens (the dynamic record
+// dialog, a federated action modal, a wizard, a confirmation) never reached
+// the table, so the row stayed stale until a manual refresh (#1020). Emitting
+// here decouples the mutation site from the list that displays the model.
+
+export type RecordMutationKind = 'create' | 'update' | 'delete'
+
+export const RECORD_MUTATION_EVENT = 'metacore:record-mutated'
+
+export interface RecordMutationDetail {
+    /** Model key as the emitter knows it (matched case-insensitively). */
+    model: string
+    kind: RecordMutationKind
+}
+
+const norm = (m: string | undefined | null) => (m ?? '').trim().toLowerCase()
+
+/** Announce a successful mutation. Safe to call outside a browser (no-op). */
+export function emitRecordMutation(model: string | undefined | null, kind: RecordMutationKind): void {
+    if (!model || typeof window === 'undefined' || typeof CustomEvent === 'undefined') return
+    try {
+        window.dispatchEvent(
+            new CustomEvent<RecordMutationDetail>(RECORD_MUTATION_EVENT, { detail: { model, kind } }),
+        )
+    } catch {
+        /* a listener must never break the save flow */
+    }
+}
+
+/**
+ * Listen for mutations of `model` (case-insensitive). Returns an unsubscribe.
+ */
+export function subscribeRecordMutations(
+    model: string | undefined | null,
+    cb: (detail: RecordMutationDetail) => void,
+): () => void {
+    if (typeof window === 'undefined') return () => {}
+    const want = norm(model)
+    const handler = (e: Event) => {
+        const d = (e as CustomEvent<RecordMutationDetail>).detail
+        if (!d || !want || norm(d.model) !== want) return
+        cb(d)
+    }
+    window.addEventListener(RECORD_MUTATION_EVENT, handler)
+    return () => window.removeEventListener(RECORD_MUTATION_EVENT, handler)
+}

package/src/types.ts

@@ -22,6 +22,48 @@ export interface ImportSpecMeta {
     instructions?: string[]
 }
 
+/** Paso de renglones de un tipo de documento (usa el editor de renglones del SDK). */
+export interface DocumentFormLines {
+    /** Campo del payload que recibe los renglones. Default: `lines` (o `lines_field` del manifest). */
+    field?: string
+    /** Columnas opcionales del editor (`discount`, `tax`, `unit`…). */
+    columns?: string[]
+    /** `sale` (precio de lista) o `cost` (compras). Default `sale`. */
+    price_source?: 'sale' | 'cost'
+    /** Al menos un renglón para guardar. Default true. */
+    required?: boolean
+    /** Título del paso. Default «Renglones». */
+    title?: string
+}
+
+/** Un tipo de documento (Factura, Nota de crédito, REP, Global, Traslado…). */
+export interface DocumentFormType {
+    key: string
+    label: string
+    description?: string
+    icon?: string
+    /** Valor que se escribe en `type_field` (p. ej. `"E"`). Default: `key`. */
+    value?: string
+    /** Campos del tipo, en el mismo vocabulario que los campos de una acción. */
+    fields: ActionFieldDef[]
+    /** Valores fijos que viajan en el alta de este tipo. */
+    defaults?: Record<string, unknown>
+    /** Con esto el tipo tiene paso de renglones. */
+    lines?: DocumentFormLines | boolean
+    /** Endpoint de alta propio de este tipo. Default: el del modelo. */
+    endpoint?: string
+    /** Texto del botón final. Default «Crear». */
+    submit_label?: string
+}
+
+export interface DocumentFormsManifest {
+    /** Columna discriminadora del modelo (p. ej. `"type"`). Sin ella no se escribe el tipo. */
+    type_field?: string
+    /** Campo por defecto de los renglones. Default `lines`. */
+    lines_field?: string
+    types: DocumentFormType[]
+}
+
 export interface TableMetadata {
     title: string
     endpoint: string
@@ -36,6 +78,20 @@ export interface TableMetadata {
     canExport?: boolean
     canImport?: boolean
     canCreate?: boolean
+    /**
+     * Formularios de alta guiados por tipo de documento (FAC-12). Cuando trae
+     * al menos un tipo, `DynamicCRUDPage` abre `DocumentFormDialog` en lugar del
+     * formulario genérico del modelo. Lo sirve el kernel o el addon; el SDK no
+     * conoce campos fiscales.
+     */
+    document_forms?: DocumentFormsManifest
+    /**
+     * Cómo se pinta el alta genérica. `generic` (o ausente) es el botón Crear.
+     * `hidden` lo quita. `action` lo quita porque el módulo trae la suya
+     * (`placement: create` o `replaces_create`). Lo sirve el kernel; un host
+     * también puede fijarlo con `ModelExtension.createMode` sin cambio de kernel.
+     */
+    create_mode?: 'generic' | 'hidden' | 'action'
     /**
      * The model's spreadsheet-import declaration, served by the kernel: the
      * columns of the generated template and the headers accepted when parsing
@@ -702,6 +758,13 @@ export interface ActionDefinition {
      *   "create"        — toolbar button that replaces the generic create button.
      */
     placement?: 'row' | 'table' | 'create'
+    /**
+     * Esta acción de toolbar sustituye al Crear genérico aunque su `placement`
+     * sea `table`. El kernel tiene que reenviar el campo; si lo recorta, el
+     * host usa `ModelExtension.primaryActionKey` o `createMode`.
+     */
+    replaces_create?: boolean
+    replacesCreate?: boolean
     /**
      * Optional addon this action depends on, stamped by the host only while it
      * is NOT installed (served as `requires_addon`; read through