@mmlogic/components 0.5.14 → 0.5.16

package/dist/types/components.d.ts

@@ -403,6 +403,11 @@ export namespace Components {
           * @default false
          */
         "showCancel": boolean;
+        /**
+          * When true, a delete button is shown next to the submit button (edit mode only — the host decides when a delete affordance makes sense, e.g. only for an existing record). Deletion itself (confirmation, the actual API call) is entirely the host's responsibility; mrd-form only emits the request via mrdDelete.
+          * @default false
+         */
+        "showDelete": boolean;
         /**
           * @default {}
          */
@@ -535,6 +540,11 @@ export namespace Components {
           * @default navigator.language
          */
         "locale": string;
+        /**
+          * The active account's linked person record (userProfile.links.person), if any. Threaded to mrd-memo-container so a top-level memo VIEW (no parent record to attach a new memo to) can still offer "New memo" by falling back to the account's own record as the container.
+          * @default null
+         */
+        "me": RelationSearchResult1 | null;
         /**
           * Open the lightbox directly with a URL (e.g. after mrdDownload on a FILE field).
          */
@@ -557,7 +567,7 @@ export namespace Components {
          */
         "setViewAggregations": (name: string, data: any) => Promise<void>;
         /**
-          * Inject the created document's href after a file-drop create, so the optimistic row becomes navigable (see mrdCreateObject).
+          * Inject the created document's href after a file-drop create, so the optimistic row becomes navigable (see mrdCreateObject). For a memo quick-create there is no optimistic row to resolve — simply reload the container's current body so the new memo shows up.
          */
         "setViewCreatedObject": (name: string, href: string) => Promise<void>;
         /**
@@ -643,6 +653,177 @@ export namespace Components {
          */
         "value": string;
     }
+    /**
+     * Owns a memo collection view: a single toolbar (view switch + "New memo") plus
+     * the two interchangeable bodies — the card list (`mrd-memo-list`) and the flat
+     * table (`mrd-table`). Mirrors `mrd-document-container`'s structure.
+     * There is no memo detail page: both "New memo" and clicking an existing memo
+     * (card or table row) open the same small dialog — just the fields a person
+     * actually fills in (body, and only the optional slots the archetype actually
+     * maps: title/labels/important). date/author/container are already known
+     * context and never shown. Create emits `mrdCreateObject` (same contract
+     * mrd-document-list already uses for its inline file-drop create); editing an
+     * existing memo emits `mrdUpdateObject` (same generic PATCH contract used
+     * elsewhere, e.g. mrd-document-list's drag-move) and optimistically patches the
+     * displayed row/card itself, since that PATCH is fire-and-forget on the host.
+     * `mrd-layout-section` renders one of these per memo VIEW / RELATED_VIEW and
+     * forwards the re-emitted load/action/create/update events to the host.
+     */
+    interface MrdMemoContainer {
+        /**
+          * Resolved `commons.memo` archetype binding.
+         */
+        "archetype": ClientArchetype;
+        /**
+          * Canonical parent href — set when this is a RELATED_VIEW embedded under a parent record, which already gives a new memo something to attach to.
+          * @default ''
+         */
+        "containerHref": string;
+        /**
+          * False when this RELATED_VIEW's parent is related via a relation other than the archetype's container slot (e.g. a person's "memos I authored" list, related via `author`) — mrd-layout-section resolves this from the item's `inverseRelation`. In that case the parent is not a valid container for a new memo, and — unlike a top-level VIEW with no context at all — falling back to `me` would be wrong too (creating a memo "on myself" from someone else's authored-memos list makes no sense), so "New memo" is hidden outright.
+          * @default true
+         */
+        "containerRelated": boolean;
+        /**
+          * The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config).
+          * @default null
+         */
+        "item": ClientLayoutItem | null;
+        /**
+          * listItems of the FIELD bound to the `labels` slot; forwarded to whichever body is mounted and used to render the dialog's label checkboxes.
+          * @default null
+         */
+        "labelsListItems": ClientListValue[] | null;
+        /**
+          * @default navigator.language
+         */
+        "locale": string;
+        /**
+          * The active account's linked person record (userProfile.links.person), if any. Used both to gate "New memo" (see effectiveContainerHref) and, on submit, to fill the author slot.
+          * @default null
+         */
+        "me": RelationSearchResult1 | null;
+        /**
+          * Parent record id — required for RELATED_VIEW path building.
+          * @default ''
+         */
+        "parentId": string;
+        /**
+          * When true, this dashboard is read-only: "New memo" is disabled with a tooltip, cards/rows are not clickable, and the embedded table's own create action is disabled too.
+          * @default false
+         */
+        "readOnly": boolean;
+        /**
+          * Re-request page 0 of whichever body is currently mounted — called by mrd-layout-section after a successful mrdCreateObject, and by this component itself after an edit to a table row (which has no per-row optimistic-patch method the way mrd-memo-list does).
+         */
+        "refresh": () => Promise<void>;
+        /**
+          * True unless this is a container-scoped RELATED_VIEW (a company's own memo tab, say) where every card's container is obviously the page you're already on — forwarded to mrd-memo-list to show/hide its per-card container link. A top-level VIEW or an author-scoped RELATED_VIEW both still need it, since the container isn't implied by the page context.
+          * @default true
+         */
+        "showContainerLink": boolean;
+        /**
+          * Lookup key used for the embedded `data-view` attribute.
+          * @default ''
+         */
+        "viewKey": string;
+    }
+    /**
+     * Card-view body for a `commons.memo` collection — the alternative to the flat
+     * `mrd-table` a `mrd-memo-container` can switch to. Deliberately simpler than
+     * `mrd-table`'s virtual-scroll internals: memo cards accumulate via a plain
+     * "load more" affordance rather than windowed rendering, since a bounded card
+     * list of notes doesn't need that complexity.
+     * Mirrors `mrd-table`'s external contract for the parts a host / mrd-layout-
+     * section already knows how to drive — `init()`, `setPage()`, the `mrdLoadPage`
+     * event shape `{ page, sort, path, qs }` — so no new host-side wiring is needed
+     * to feed it data.
+     * There is no separate memo detail page: clicking a card opens mrd-memo-
+     * container's quick-edit dialog directly (mrdEdit), the same dialog "New memo"
+     * uses for creation.
+     */
+    interface MrdMemoList {
+        /**
+          * Resolved `commons.memo` archetype binding.
+         */
+        "archetype": ClientArchetype;
+        /**
+          * Reset and request page 0. Call after setting all props, mirrors mrd-table.init().
+         */
+        "init": () => Promise<void>;
+        /**
+          * The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config).
+          * @default null
+         */
+        "item": ClientLayoutItem | null;
+        /**
+          * listItems of the FIELD bound to the `labels` slot, resolved by mrd-layout-section from its own items array, same reason mrd-memo-view needs it.
+          * @default null
+         */
+        "labelsListItems": ClientListValue[] | null;
+        /**
+          * @default navigator.language
+         */
+        "locale": string;
+        /**
+          * Records per page (must match API page size).
+          * @default 20
+         */
+        "pageSize": number;
+        /**
+          * Parent record id — required for RELATED_VIEW path building.
+          * @default ''
+         */
+        "parentId": string;
+        /**
+          * Optimistically merge an edit into the matching row — mrdUpdateObject's PATCH is fire-and-forget on the host side, so this is what makes an edit visible immediately rather than only after the next full reload.
+         */
+        "patchRow": (href: string, values: Record<string, unknown>) => Promise<void>;
+        /**
+          * When true, cards are not clickable (no mrdEdit) — matches mrd-table's own readOnly gating on its create action.
+          * @default false
+         */
+        "readOnly": boolean;
+        /**
+          * Optimistically drop a deleted row — mrdDeleteObject's DELETE is fire-and- forget on the host side, same reasoning as patchRow().
+         */
+        "removeRow": (href: string) => Promise<void>;
+        /**
+          * Inject the rows for a page (0-based); page 0 replaces, later pages append.
+         */
+        "setPage": (pageNumber: number, rows: Record<string, unknown>[], hasNext?: boolean) => Promise<void>;
+        /**
+          * False when the list is already scoped to its own container (a company's own memo tab) — showing "belongs to: <this same company>" on every card there would be redundant. True everywhere else (top-level VIEW, or a RELATED_VIEW scoped by a different relation, e.g. a person's authored-memos list).
+          * @default true
+         */
+        "showContainerLink": boolean;
+    }
+    /**
+     * Archetype-driven single-memo view. Given a `commons.memo` binding and a data
+     * record, renders the memo the way a note should read: the title and body are
+     * the prominent content, author and timestamp sit below as a subtle metadata
+     * line — not the other way around.
+     */
+    interface MrdMemoView {
+        /**
+          * Resolved `commons.memo` binding: slot name → concrete field/relation name.
+         */
+        "archetype": ClientArchetype;
+        /**
+          * The data record from the /data endpoint. Fields keyed by name; relations under `_links`.
+          * @default {}
+         */
+        "data": Record<string, unknown>;
+        /**
+          * listItems of the FIELD bound to the `labels` slot, resolved by mrd-layout-section from its own items array (archetype metadata does not publish listItems), so the label badges get a real label/color instead of the raw stored key.
+          * @default null
+         */
+        "labelsListItems": ClientListValue[] | null;
+        /**
+          * @default navigator.language
+         */
+        "locale": string;
+    }
     /**
      * Merges two DataObjects of the same basic type (FINDING-0114 / TASK-0177).
      * Never performs network I/O itself: it emits `mrdSearch` (host searches and
@@ -909,6 +1090,11 @@ export namespace Components {
         "value": string;
     }
     interface MrdTextareaField {
+        /**
+          * Focus the editor as soon as it's ready — opt-in, since auto-focusing every textarea field on mount would be wrong for a regular multi-field form.
+          * @default false
+         */
+        "autofocus": boolean;
         /**
           * @default false
          */
@@ -1037,6 +1223,18 @@ export interface MrdLongtextFieldCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLMrdLongtextFieldElement;
 }
+export interface MrdMemoContainerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLMrdMemoContainerElement;
+}
+export interface MrdMemoListCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLMrdMemoListElement;
+}
+export interface MrdMemoViewCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLMrdMemoViewElement;
+}
 export interface MrdMergeViewCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLMrdMergeViewElement;
@@ -1341,6 +1539,7 @@ declare global {
     interface HTMLMrdFormElementEventMap {
         "mrdSubmit": Record<string, unknown>;
         "mrdCancel": void;
+        "mrdDelete": void;
         "mrdSearch": { name: string; query: string; relatedClass: string };
         "mrdFetchAll": { name: string; relatedClass: string; mostSignificantClass?: string; commonRelation?: string; filter?: string; filterValue?: string };
         "mrdUpload": { name: string; file: File };
@@ -1440,6 +1639,7 @@ declare global {
         "mrdLoadViewAggregations": { name: string; dataClass: string; path: string; qs: string; aggQs: string };
         "mrdLoadViewDistinct": { name: string; nodeId: string; distinct: string; path: string; qs: string };
         "mrdUpdateObject": { href: string; values: Record<string, unknown> };
+        "mrdDeleteObject": { href: string };
         "mrdViewUpload": { name: string; file: File };
         "mrdCreateObject": { name: string; path: string; values: Record<string, unknown> };
     }
@@ -1493,6 +1693,101 @@ declare global {
         prototype: HTMLMrdLongtextFieldElement;
         new (): HTMLMrdLongtextFieldElement;
     };
+    interface HTMLMrdMemoContainerElementEventMap {
+        "mrdLoadPage": { page: number; sort: string; path: string; qs: string };
+        "mrdLoadAggregations": { path: string; qs: string; aggQs: string };
+        "mrdNavigate": { href?: string; label: string };
+        "mrdAction": { action: string; path?: string; qs?: string; parentPath?: string | null; basicType?: string };
+        "mrdCreateObject": { path: string; values: Record<string, unknown> };
+        "mrdUpdateObject": { href: string; values: Record<string, unknown> };
+        "mrdDeleteObject": { href: string };
+    }
+    /**
+     * Owns a memo collection view: a single toolbar (view switch + "New memo") plus
+     * the two interchangeable bodies — the card list (`mrd-memo-list`) and the flat
+     * table (`mrd-table`). Mirrors `mrd-document-container`'s structure.
+     * There is no memo detail page: both "New memo" and clicking an existing memo
+     * (card or table row) open the same small dialog — just the fields a person
+     * actually fills in (body, and only the optional slots the archetype actually
+     * maps: title/labels/important). date/author/container are already known
+     * context and never shown. Create emits `mrdCreateObject` (same contract
+     * mrd-document-list already uses for its inline file-drop create); editing an
+     * existing memo emits `mrdUpdateObject` (same generic PATCH contract used
+     * elsewhere, e.g. mrd-document-list's drag-move) and optimistically patches the
+     * displayed row/card itself, since that PATCH is fire-and-forget on the host.
+     * `mrd-layout-section` renders one of these per memo VIEW / RELATED_VIEW and
+     * forwards the re-emitted load/action/create/update events to the host.
+     */
+    interface HTMLMrdMemoContainerElement extends Components.MrdMemoContainer, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLMrdMemoContainerElementEventMap>(type: K, listener: (this: HTMLMrdMemoContainerElement, ev: MrdMemoContainerCustomEvent<HTMLMrdMemoContainerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLMrdMemoContainerElementEventMap>(type: K, listener: (this: HTMLMrdMemoContainerElement, ev: MrdMemoContainerCustomEvent<HTMLMrdMemoContainerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLMrdMemoContainerElement: {
+        prototype: HTMLMrdMemoContainerElement;
+        new (): HTMLMrdMemoContainerElement;
+    };
+    interface HTMLMrdMemoListElementEventMap {
+        "mrdLoadPage": { page: number; sort: string; path: string; qs: string };
+        "mrdEdit": { row: Record<string, unknown> };
+        "mrdNavigate": { href?: string; label: string };
+    }
+    /**
+     * Card-view body for a `commons.memo` collection — the alternative to the flat
+     * `mrd-table` a `mrd-memo-container` can switch to. Deliberately simpler than
+     * `mrd-table`'s virtual-scroll internals: memo cards accumulate via a plain
+     * "load more" affordance rather than windowed rendering, since a bounded card
+     * list of notes doesn't need that complexity.
+     * Mirrors `mrd-table`'s external contract for the parts a host / mrd-layout-
+     * section already knows how to drive — `init()`, `setPage()`, the `mrdLoadPage`
+     * event shape `{ page, sort, path, qs }` — so no new host-side wiring is needed
+     * to feed it data.
+     * There is no separate memo detail page: clicking a card opens mrd-memo-
+     * container's quick-edit dialog directly (mrdEdit), the same dialog "New memo"
+     * uses for creation.
+     */
+    interface HTMLMrdMemoListElement extends Components.MrdMemoList, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLMrdMemoListElementEventMap>(type: K, listener: (this: HTMLMrdMemoListElement, ev: MrdMemoListCustomEvent<HTMLMrdMemoListElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLMrdMemoListElementEventMap>(type: K, listener: (this: HTMLMrdMemoListElement, ev: MrdMemoListCustomEvent<HTMLMrdMemoListElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLMrdMemoListElement: {
+        prototype: HTMLMrdMemoListElement;
+        new (): HTMLMrdMemoListElement;
+    };
+    interface HTMLMrdMemoViewElementEventMap {
+        "mrdNavigate": { href?: string; label: string };
+    }
+    /**
+     * Archetype-driven single-memo view. Given a `commons.memo` binding and a data
+     * record, renders the memo the way a note should read: the title and body are
+     * the prominent content, author and timestamp sit below as a subtle metadata
+     * line — not the other way around.
+     */
+    interface HTMLMrdMemoViewElement extends Components.MrdMemoView, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLMrdMemoViewElementEventMap>(type: K, listener: (this: HTMLMrdMemoViewElement, ev: MrdMemoViewCustomEvent<HTMLMrdMemoViewElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLMrdMemoViewElementEventMap>(type: K, listener: (this: HTMLMrdMemoViewElement, ev: MrdMemoViewCustomEvent<HTMLMrdMemoViewElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLMrdMemoViewElement: {
+        prototype: HTMLMrdMemoViewElement;
+        new (): HTMLMrdMemoViewElement;
+    };
     interface HTMLMrdMergeViewElementEventMap {
         "mrdSearch": { query: string; basicType: string; mostSignificantClass?: string };
         "mrdMerge": { winnerHref: string; loserHref: string; patch: Record<string, unknown> };
@@ -1672,6 +1967,9 @@ declare global {
         "mrd-layout-section": HTMLMrdLayoutSectionElement;
         "mrd-list-field": HTMLMrdListFieldElement;
         "mrd-longtext-field": HTMLMrdLongtextFieldElement;
+        "mrd-memo-container": HTMLMrdMemoContainerElement;
+        "mrd-memo-list": HTMLMrdMemoListElement;
+        "mrd-memo-view": HTMLMrdMemoViewElement;
         "mrd-merge-view": HTMLMrdMergeViewElement;
         "mrd-number-field": HTMLMrdNumberFieldElement;
         "mrd-relation-field": HTMLMrdRelationFieldElement;
@@ -2137,6 +2435,7 @@ declare namespace LocalJSX {
          */
         "me"?: RelationSearchResult | null;
         "onMrdCancel"?: (event: MrdFormCustomEvent<void>) => void;
+        "onMrdDelete"?: (event: MrdFormCustomEvent<void>) => void;
         "onMrdFetchAll"?: (event: MrdFormCustomEvent<{ name: string; relatedClass: string; mostSignificantClass?: string; commonRelation?: string; filter?: string; filterValue?: string }>) => void;
         "onMrdSearch"?: (event: MrdFormCustomEvent<{ name: string; query: string; relatedClass: string }>) => void;
         "onMrdSubmit"?: (event: MrdFormCustomEvent<Record<string, unknown>>) => void;
@@ -2156,6 +2455,11 @@ declare namespace LocalJSX {
           * @default false
          */
         "showCancel"?: boolean;
+        /**
+          * When true, a delete button is shown next to the submit button (edit mode only — the host decides when a delete affordance makes sense, e.g. only for an existing record). Deletion itself (confirmation, the actual API call) is entirely the host's responsibility; mrd-form only emits the request via mrdDelete.
+          * @default false
+         */
+        "showDelete"?: boolean;
         /**
           * @default {}
          */
@@ -2308,6 +2612,11 @@ declare namespace LocalJSX {
           * @default navigator.language
          */
         "locale"?: string;
+        /**
+          * The active account's linked person record (userProfile.links.person), if any. Threaded to mrd-memo-container so a top-level memo VIEW (no parent record to attach a new memo to) can still offer "New memo" by falling back to the account's own record as the container.
+          * @default null
+         */
+        "me"?: RelationSearchResult1 | null;
         /**
           * Re-emitted from an embedded mrd-document-view (commons.document single-object view) whenever its file slot's value changes. The component never renders the file itself — the host resolves the href(s) and decides how/whether to show them, e.g. in a panel next to this mrd-layout-section.
          */
@@ -2316,6 +2625,10 @@ declare namespace LocalJSX {
           * Create a new document from an uploaded file; host POSTs `values` to `path`, then calls setViewCreatedObject(name, href) with the new object's href.
          */
         "onMrdCreateObject"?: (event: MrdLayoutSectionCustomEvent<{ name: string; path: string; values: Record<string, unknown> }>) => void;
+        /**
+          * Confirmed delete from an embedded memo dialog. Host DELETEs `href` — fire- and-forget, the row is already removed optimistically on the component side.
+         */
+        "onMrdDeleteObject"?: (event: MrdLayoutSectionCustomEvent<{ href: string }>) => void;
         "onMrdDownload"?: (event: MrdLayoutSectionCustomEvent<{ href: string; fileName: string }>) => void;
         /**
           * Fired once on load for each IMAGE field that has an href; host resolves the URL and calls setImagePreview().
@@ -2430,6 +2743,195 @@ declare namespace LocalJSX {
          */
         "value"?: string;
     }
+    /**
+     * Owns a memo collection view: a single toolbar (view switch + "New memo") plus
+     * the two interchangeable bodies — the card list (`mrd-memo-list`) and the flat
+     * table (`mrd-table`). Mirrors `mrd-document-container`'s structure.
+     * There is no memo detail page: both "New memo" and clicking an existing memo
+     * (card or table row) open the same small dialog — just the fields a person
+     * actually fills in (body, and only the optional slots the archetype actually
+     * maps: title/labels/important). date/author/container are already known
+     * context and never shown. Create emits `mrdCreateObject` (same contract
+     * mrd-document-list already uses for its inline file-drop create); editing an
+     * existing memo emits `mrdUpdateObject` (same generic PATCH contract used
+     * elsewhere, e.g. mrd-document-list's drag-move) and optimistically patches the
+     * displayed row/card itself, since that PATCH is fire-and-forget on the host.
+     * `mrd-layout-section` renders one of these per memo VIEW / RELATED_VIEW and
+     * forwards the re-emitted load/action/create/update events to the host.
+     */
+    interface MrdMemoContainer {
+        /**
+          * Resolved `commons.memo` archetype binding.
+         */
+        "archetype": ClientArchetype;
+        /**
+          * Canonical parent href — set when this is a RELATED_VIEW embedded under a parent record, which already gives a new memo something to attach to.
+          * @default ''
+         */
+        "containerHref"?: string;
+        /**
+          * False when this RELATED_VIEW's parent is related via a relation other than the archetype's container slot (e.g. a person's "memos I authored" list, related via `author`) — mrd-layout-section resolves this from the item's `inverseRelation`. In that case the parent is not a valid container for a new memo, and — unlike a top-level VIEW with no context at all — falling back to `me` would be wrong too (creating a memo "on myself" from someone else's authored-memos list makes no sense), so "New memo" is hidden outright.
+          * @default true
+         */
+        "containerRelated"?: boolean;
+        /**
+          * The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config).
+          * @default null
+         */
+        "item"?: ClientLayoutItem | null;
+        /**
+          * listItems of the FIELD bound to the `labels` slot; forwarded to whichever body is mounted and used to render the dialog's label checkboxes.
+          * @default null
+         */
+        "labelsListItems"?: ClientListValue[] | null;
+        /**
+          * @default navigator.language
+         */
+        "locale"?: string;
+        /**
+          * The active account's linked person record (userProfile.links.person), if any. Used both to gate "New memo" (see effectiveContainerHref) and, on submit, to fill the author slot.
+          * @default null
+         */
+        "me"?: RelationSearchResult1 | null;
+        /**
+          * Only the embedded table's own toolbar (export, etc.) still routes through this.
+         */
+        "onMrdAction"?: (event: MrdMemoContainerCustomEvent<{ action: string; path?: string; qs?: string; parentPath?: string | null; basicType?: string }>) => void;
+        /**
+          * Quick-create submit. Host POSTs `values` to `path`, same as mrd-document-list's.
+         */
+        "onMrdCreateObject"?: (event: MrdMemoContainerCustomEvent<{ path: string; values: Record<string, unknown> }>) => void;
+        /**
+          * Confirmed delete. Host DELETEs `href` — fire-and-forget, same as mrdUpdateObject; the row is removed optimistically here rather than waiting on a callback.
+         */
+        "onMrdDeleteObject"?: (event: MrdMemoContainerCustomEvent<{ href: string }>) => void;
+        "onMrdLoadAggregations"?: (event: MrdMemoContainerCustomEvent<{ path: string; qs: string; aggQs: string }>) => void;
+        "onMrdLoadPage"?: (event: MrdMemoContainerCustomEvent<{ page: number; sort: string; path: string; qs: string }>) => void;
+        /**
+          * A card's container link was clicked — real navigation, unrelated to the quick-edit dialog (mrdEdit is internal, handled by this component itself).
+         */
+        "onMrdNavigate"?: (event: MrdMemoContainerCustomEvent<{ href?: string; label: string }>) => void;
+        /**
+          * Quick-edit submit. Host PATCHes `href` with `values`, same as mrd-document-list's drag-move.
+         */
+        "onMrdUpdateObject"?: (event: MrdMemoContainerCustomEvent<{ href: string; values: Record<string, unknown> }>) => void;
+        /**
+          * Parent record id — required for RELATED_VIEW path building.
+          * @default ''
+         */
+        "parentId"?: string;
+        /**
+          * When true, this dashboard is read-only: "New memo" is disabled with a tooltip, cards/rows are not clickable, and the embedded table's own create action is disabled too.
+          * @default false
+         */
+        "readOnly"?: boolean;
+        /**
+          * True unless this is a container-scoped RELATED_VIEW (a company's own memo tab, say) where every card's container is obviously the page you're already on — forwarded to mrd-memo-list to show/hide its per-card container link. A top-level VIEW or an author-scoped RELATED_VIEW both still need it, since the container isn't implied by the page context.
+          * @default true
+         */
+        "showContainerLink"?: boolean;
+        /**
+          * Lookup key used for the embedded `data-view` attribute.
+          * @default ''
+         */
+        "viewKey"?: string;
+    }
+    /**
+     * Card-view body for a `commons.memo` collection — the alternative to the flat
+     * `mrd-table` a `mrd-memo-container` can switch to. Deliberately simpler than
+     * `mrd-table`'s virtual-scroll internals: memo cards accumulate via a plain
+     * "load more" affordance rather than windowed rendering, since a bounded card
+     * list of notes doesn't need that complexity.
+     * Mirrors `mrd-table`'s external contract for the parts a host / mrd-layout-
+     * section already knows how to drive — `init()`, `setPage()`, the `mrdLoadPage`
+     * event shape `{ page, sort, path, qs }` — so no new host-side wiring is needed
+     * to feed it data.
+     * There is no separate memo detail page: clicking a card opens mrd-memo-
+     * container's quick-edit dialog directly (mrdEdit), the same dialog "New memo"
+     * uses for creation.
+     */
+    interface MrdMemoList {
+        /**
+          * Resolved `commons.memo` archetype binding.
+         */
+        "archetype": ClientArchetype;
+        /**
+          * The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config).
+          * @default null
+         */
+        "item"?: ClientLayoutItem | null;
+        /**
+          * listItems of the FIELD bound to the `labels` slot, resolved by mrd-layout-section from its own items array, same reason mrd-memo-view needs it.
+          * @default null
+         */
+        "labelsListItems"?: ClientListValue[] | null;
+        /**
+          * @default navigator.language
+         */
+        "locale"?: string;
+        /**
+          * A card was clicked (and not read-only). mrd-memo-container opens its quick- edit dialog pre-filled from `row` — no navigation, no detail page.
+         */
+        "onMrdEdit"?: (event: MrdMemoListCustomEvent<{ row: Record<string, unknown> }>) => void;
+        /**
+          * Fired when a page needs fetching; same shape as mrd-table's mrdLoadPage minus `qs`'s column-filter support (cards have no filter UI) — host calls setPage() with the result.
+         */
+        "onMrdLoadPage"?: (event: MrdMemoListCustomEvent<{ page: number; sort: string; path: string; qs: string }>) => void;
+        /**
+          * The container link on a card was clicked — this is real navigation (to the container record), unrelated to mrdEdit.
+         */
+        "onMrdNavigate"?: (event: MrdMemoListCustomEvent<{ href?: string; label: string }>) => void;
+        /**
+          * Records per page (must match API page size).
+          * @default 20
+         */
+        "pageSize"?: number;
+        /**
+          * Parent record id — required for RELATED_VIEW path building.
+          * @default ''
+         */
+        "parentId"?: string;
+        /**
+          * When true, cards are not clickable (no mrdEdit) — matches mrd-table's own readOnly gating on its create action.
+          * @default false
+         */
+        "readOnly"?: boolean;
+        /**
+          * False when the list is already scoped to its own container (a company's own memo tab) — showing "belongs to: <this same company>" on every card there would be redundant. True everywhere else (top-level VIEW, or a RELATED_VIEW scoped by a different relation, e.g. a person's authored-memos list).
+          * @default true
+         */
+        "showContainerLink"?: boolean;
+    }
+    /**
+     * Archetype-driven single-memo view. Given a `commons.memo` binding and a data
+     * record, renders the memo the way a note should read: the title and body are
+     * the prominent content, author and timestamp sit below as a subtle metadata
+     * line — not the other way around.
+     */
+    interface MrdMemoView {
+        /**
+          * Resolved `commons.memo` binding: slot name → concrete field/relation name.
+         */
+        "archetype": ClientArchetype;
+        /**
+          * The data record from the /data endpoint. Fields keyed by name; relations under `_links`.
+          * @default {}
+         */
+        "data"?: Record<string, unknown>;
+        /**
+          * listItems of the FIELD bound to the `labels` slot, resolved by mrd-layout-section from its own items array (archetype metadata does not publish listItems), so the label badges get a real label/color instead of the raw stored key.
+          * @default null
+         */
+        "labelsListItems"?: ClientListValue[] | null;
+        /**
+          * @default navigator.language
+         */
+        "locale"?: string;
+        /**
+          * Navigate to the author or the container. Host resolves the href and routes.
+         */
+        "onMrdNavigate"?: (event: MrdMemoViewCustomEvent<{ href?: string; label: string }>) => void;
+    }
     /**
      * Merges two DataObjects of the same basic type (FINDING-0114 / TASK-0177).
      * Never performs network I/O itself: it emits `mrdSearch` (host searches and
@@ -2712,6 +3214,11 @@ declare namespace LocalJSX {
         "value"?: string;
     }
     interface MrdTextareaField {
+        /**
+          * Focus the editor as soon as it's ready — opt-in, since auto-focusing every textarea field on mount would be wrong for a regular multi-field form.
+          * @default false
+         */
+        "autofocus"?: boolean;
         /**
           * @default false
          */
@@ -2850,6 +3357,7 @@ declare namespace LocalJSX {
         "referenceHref": string;
         "referenceClass": string;
         "showCancel": boolean;
+        "showDelete": boolean;
     }
     interface MrdHyperlinkFieldAttributes {
         "name": string;
@@ -2895,6 +3403,25 @@ declare namespace LocalJSX {
         "disabled": boolean;
         "locale": string;
     }
+    interface MrdMemoContainerAttributes {
+        "parentId": string;
+        "containerHref": string;
+        "containerRelated": boolean;
+        "showContainerLink": boolean;
+        "viewKey": string;
+        "locale": string;
+        "readOnly": boolean;
+    }
+    interface MrdMemoListAttributes {
+        "parentId": string;
+        "pageSize": number;
+        "locale": string;
+        "readOnly": boolean;
+        "showContainerLink": boolean;
+    }
+    interface MrdMemoViewAttributes {
+        "locale": string;
+    }
     interface MrdMergeViewAttributes {
         "locale": string;
         "basicType": string;
@@ -2963,6 +3490,7 @@ declare namespace LocalJSX {
         "required": boolean;
         "disabled": boolean;
         "locale": string;
+        "autofocus": boolean;
     }
     interface MrdTimeFieldAttributes {
         "name": string;
@@ -2992,6 +3520,9 @@ declare namespace LocalJSX {
         "mrd-layout-section": Omit<MrdLayoutSection, keyof MrdLayoutSectionAttributes> & { [K in keyof MrdLayoutSection & keyof MrdLayoutSectionAttributes]?: MrdLayoutSection[K] } & { [K in keyof MrdLayoutSection & keyof MrdLayoutSectionAttributes as `attr:${K}`]?: MrdLayoutSectionAttributes[K] } & { [K in keyof MrdLayoutSection & keyof MrdLayoutSectionAttributes as `prop:${K}`]?: MrdLayoutSection[K] };
         "mrd-list-field": Omit<MrdListField, keyof MrdListFieldAttributes> & { [K in keyof MrdListField & keyof MrdListFieldAttributes]?: MrdListField[K] } & { [K in keyof MrdListField & keyof MrdListFieldAttributes as `attr:${K}`]?: MrdListFieldAttributes[K] } & { [K in keyof MrdListField & keyof MrdListFieldAttributes as `prop:${K}`]?: MrdListField[K] };
         "mrd-longtext-field": Omit<MrdLongtextField, keyof MrdLongtextFieldAttributes> & { [K in keyof MrdLongtextField & keyof MrdLongtextFieldAttributes]?: MrdLongtextField[K] } & { [K in keyof MrdLongtextField & keyof MrdLongtextFieldAttributes as `attr:${K}`]?: MrdLongtextFieldAttributes[K] } & { [K in keyof MrdLongtextField & keyof MrdLongtextFieldAttributes as `prop:${K}`]?: MrdLongtextField[K] };
+        "mrd-memo-container": Omit<MrdMemoContainer, keyof MrdMemoContainerAttributes> & { [K in keyof MrdMemoContainer & keyof MrdMemoContainerAttributes]?: MrdMemoContainer[K] } & { [K in keyof MrdMemoContainer & keyof MrdMemoContainerAttributes as `attr:${K}`]?: MrdMemoContainerAttributes[K] } & { [K in keyof MrdMemoContainer & keyof MrdMemoContainerAttributes as `prop:${K}`]?: MrdMemoContainer[K] };
+        "mrd-memo-list": Omit<MrdMemoList, keyof MrdMemoListAttributes> & { [K in keyof MrdMemoList & keyof MrdMemoListAttributes]?: MrdMemoList[K] } & { [K in keyof MrdMemoList & keyof MrdMemoListAttributes as `attr:${K}`]?: MrdMemoListAttributes[K] } & { [K in keyof MrdMemoList & keyof MrdMemoListAttributes as `prop:${K}`]?: MrdMemoList[K] };
+        "mrd-memo-view": Omit<MrdMemoView, keyof MrdMemoViewAttributes> & { [K in keyof MrdMemoView & keyof MrdMemoViewAttributes]?: MrdMemoView[K] } & { [K in keyof MrdMemoView & keyof MrdMemoViewAttributes as `attr:${K}`]?: MrdMemoViewAttributes[K] } & { [K in keyof MrdMemoView & keyof MrdMemoViewAttributes as `prop:${K}`]?: MrdMemoView[K] };
         "mrd-merge-view": Omit<MrdMergeView, keyof MrdMergeViewAttributes> & { [K in keyof MrdMergeView & keyof MrdMergeViewAttributes]?: MrdMergeView[K] } & { [K in keyof MrdMergeView & keyof MrdMergeViewAttributes as `attr:${K}`]?: MrdMergeViewAttributes[K] } & { [K in keyof MrdMergeView & keyof MrdMergeViewAttributes as `prop:${K}`]?: MrdMergeView[K] };
         "mrd-number-field": Omit<MrdNumberField, keyof MrdNumberFieldAttributes> & { [K in keyof MrdNumberField & keyof MrdNumberFieldAttributes]?: MrdNumberField[K] } & { [K in keyof MrdNumberField & keyof MrdNumberFieldAttributes as `attr:${K}`]?: MrdNumberFieldAttributes[K] } & { [K in keyof MrdNumberField & keyof MrdNumberFieldAttributes as `prop:${K}`]?: MrdNumberField[K] };
         "mrd-relation-field": Omit<MrdRelationField, keyof MrdRelationFieldAttributes> & { [K in keyof MrdRelationField & keyof MrdRelationFieldAttributes]?: MrdRelationField[K] } & { [K in keyof MrdRelationField & keyof MrdRelationFieldAttributes as `attr:${K}`]?: MrdRelationFieldAttributes[K] } & { [K in keyof MrdRelationField & keyof MrdRelationFieldAttributes as `prop:${K}`]?: MrdRelationField[K] };
@@ -3090,6 +3621,45 @@ declare module "@stencil/core" {
             "mrd-layout-section": LocalJSX.IntrinsicElements["mrd-layout-section"] & JSXBase.HTMLAttributes<HTMLMrdLayoutSectionElement>;
             "mrd-list-field": LocalJSX.IntrinsicElements["mrd-list-field"] & JSXBase.HTMLAttributes<HTMLMrdListFieldElement>;
             "mrd-longtext-field": LocalJSX.IntrinsicElements["mrd-longtext-field"] & JSXBase.HTMLAttributes<HTMLMrdLongtextFieldElement>;
+            /**
+             * Owns a memo collection view: a single toolbar (view switch + "New memo") plus
+             * the two interchangeable bodies — the card list (`mrd-memo-list`) and the flat
+             * table (`mrd-table`). Mirrors `mrd-document-container`'s structure.
+             * There is no memo detail page: both "New memo" and clicking an existing memo
+             * (card or table row) open the same small dialog — just the fields a person
+             * actually fills in (body, and only the optional slots the archetype actually
+             * maps: title/labels/important). date/author/container are already known
+             * context and never shown. Create emits `mrdCreateObject` (same contract
+             * mrd-document-list already uses for its inline file-drop create); editing an
+             * existing memo emits `mrdUpdateObject` (same generic PATCH contract used
+             * elsewhere, e.g. mrd-document-list's drag-move) and optimistically patches the
+             * displayed row/card itself, since that PATCH is fire-and-forget on the host.
+             * `mrd-layout-section` renders one of these per memo VIEW / RELATED_VIEW and
+             * forwards the re-emitted load/action/create/update events to the host.
+             */
+            "mrd-memo-container": LocalJSX.IntrinsicElements["mrd-memo-container"] & JSXBase.HTMLAttributes<HTMLMrdMemoContainerElement>;
+            /**
+             * Card-view body for a `commons.memo` collection — the alternative to the flat
+             * `mrd-table` a `mrd-memo-container` can switch to. Deliberately simpler than
+             * `mrd-table`'s virtual-scroll internals: memo cards accumulate via a plain
+             * "load more" affordance rather than windowed rendering, since a bounded card
+             * list of notes doesn't need that complexity.
+             * Mirrors `mrd-table`'s external contract for the parts a host / mrd-layout-
+             * section already knows how to drive — `init()`, `setPage()`, the `mrdLoadPage`
+             * event shape `{ page, sort, path, qs }` — so no new host-side wiring is needed
+             * to feed it data.
+             * There is no separate memo detail page: clicking a card opens mrd-memo-
+             * container's quick-edit dialog directly (mrdEdit), the same dialog "New memo"
+             * uses for creation.
+             */
+            "mrd-memo-list": LocalJSX.IntrinsicElements["mrd-memo-list"] & JSXBase.HTMLAttributes<HTMLMrdMemoListElement>;
+            /**
+             * Archetype-driven single-memo view. Given a `commons.memo` binding and a data
+             * record, renders the memo the way a note should read: the title and body are
+             * the prominent content, author and timestamp sit below as a subtle metadata
+             * line — not the other way around.
+             */
+            "mrd-memo-view": LocalJSX.IntrinsicElements["mrd-memo-view"] & JSXBase.HTMLAttributes<HTMLMrdMemoViewElement>;
             /**
              * Merges two DataObjects of the same basic type (FINDING-0114 / TASK-0177).
              * Never performs network I/O itself: it emits `mrdSearch` (host searches and