golem-ui 0.1.1

package/dist/components/Chat/index.d.ts

@@ -0,0 +1,6 @@
+export { Chat } from './Chat';
+export type { ChatAdapters, ChatSlots } from './Chat';
+export { chatConfigSchema } from './Chat.config';
+export type { ChatConfig, ChatConfigInput } from './Chat.config';
+export { chatDocs } from './Chat.docs';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Chat/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA"}

package/dist/components/Editor/Editor.config.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const editorConfigSchema: z.ZodObject<{
+    collection: z.ZodString;
+    id: z.ZodString;
+    bodyField: z.ZodDefault<z.ZodString>;
+    versionField: z.ZodDefault<z.ZodString>;
+    autosaveMs: z.ZodDefault<z.ZodNumber>;
+    preview: z.ZodDefault<z.ZodEnum<{
+        split: "split";
+        off: "off";
+        toggle: "toggle";
+    }>>;
+    outline: z.ZodDefault<z.ZodBoolean>;
+    readOnly: z.ZodDefault<z.ZodBoolean>;
+    placeholder: z.ZodDefault<z.ZodString>;
+    highlightMs: z.ZodDefault<z.ZodNumber>;
+    locale: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type EditorConfig = z.output<typeof editorConfigSchema>;
+export type EditorConfigInput = z.input<typeof editorConfigSchema>;
+//# sourceMappingURL=Editor.config.d.ts.map

package/dist/components/Editor/Editor.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Editor.config.d.ts","sourceRoot":"","sources":["../../../src/components/Editor/Editor.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;kBAqF3B,CAAA;AAEJ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/components/Editor/Editor.d.ts

@@ -0,0 +1,46 @@
+import { type GolemProps } from '../../abi';
+import { type ClockAdapter, type RecordsAdapter } from '../../adapters';
+export interface EditorAdapters {
+    records: RecordsAdapter;
+    clock: ClockAdapter;
+}
+export interface EditorSlots {
+    /**
+     * Work the person had not saved when they last left — from a local draft store, say. The editor
+     * opens on it instead of the record's body, dirty against the record's version, so the first
+     * thing that arrives from the agent is merged rather than dropped on top of it.
+     */
+    draft?: string;
+}
+export declare const Editor: import("react").FunctionComponent<GolemProps<{
+    collection: string;
+    id: string;
+    bodyField?: string | undefined;
+    versionField?: string | undefined;
+    autosaveMs?: number | undefined;
+    preview?: "split" | "off" | "toggle" | undefined;
+    outline?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    placeholder?: string | undefined;
+    highlightMs?: number | undefined;
+    locale?: string | undefined;
+}, EditorAdapters, EditorSlots>> & {
+    schema: import("zod").ZodObject<{
+        collection: import("zod").ZodString;
+        id: import("zod").ZodString;
+        bodyField: import("zod").ZodDefault<import("zod").ZodString>;
+        versionField: import("zod").ZodDefault<import("zod").ZodString>;
+        autosaveMs: import("zod").ZodDefault<import("zod").ZodNumber>;
+        preview: import("zod").ZodDefault<import("zod").ZodEnum<{
+            split: "split";
+            off: "off";
+            toggle: "toggle";
+        }>>;
+        outline: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        readOnly: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        placeholder: import("zod").ZodDefault<import("zod").ZodString>;
+        highlightMs: import("zod").ZodDefault<import("zod").ZodNumber>;
+        locale: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+};
+//# sourceMappingURL=Editor.d.ts.map

package/dist/components/Editor/Editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Editor.d.ts","sourceRoot":"","sources":["../../../src/components/Editor/Editor.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AAC5D,OAAO,EAAqB,KAAK,YAAY,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAO1F,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,EAAE,YAAY,CAAA;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AA8uBD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIjB,CAAA"}

package/dist/components/Editor/Editor.docs.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentDocs } from '../../abi';
+export declare const editorDocs: ComponentDocs;
+//# sourceMappingURL=Editor.docs.d.ts.map

package/dist/components/Editor/Editor.docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Editor.docs.d.ts","sourceRoot":"","sources":["../../../src/components/Editor/Editor.docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,eAAO,MAAM,UAAU,EAAE,aA6IxB,CAAA"}

package/dist/components/Editor/index.d.ts

@@ -0,0 +1,6 @@
+export { Editor } from './Editor';
+export type { EditorAdapters, EditorSlots } from './Editor';
+export { editorConfigSchema } from './Editor.config';
+export type { EditorConfig, EditorConfigInput } from './Editor.config';
+export { editorDocs } from './Editor.docs';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACpD,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA"}

package/dist/components/Editor/source.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Markdown source styled where it stands: the characters the person typed, still all there, wearing
+ * the weight and colour of what they mean. It is not a preview and it is not a WYSIWYG surface —
+ * `##` stays `##`, and deleting one is how a heading stops being a heading.
+ *
+ * It is drawn under a transparent textarea, so **every span has to keep the monospace advance
+ * width**: weight, colour and background only. A larger heading or an italic run would slide the
+ * text out from under the caret.
+ */
+export type LineKind = 'heading' | 'code' | 'list' | 'quote' | 'plain';
+export interface SourceLine {
+    text: string;
+    kind: LineKind;
+}
+/** A fence opens and closes across lines, so a line's kind is only knowable in document order. */
+export declare function scanSource(lines: string[]): SourceLine[];
+/** Every heading in the document, in order, for the outline. */
+export declare function headingsOf(lines: string[]): {
+    line: number;
+    level: number;
+    text: string;
+}[];
+declare const LINE_CLASS: Record<LineKind, string>;
+export declare function SourceRow({ line, index }: {
+    line: SourceLine;
+    index: number;
+}): import("react").JSX.Element;
+export { LINE_CLASS };
+//# sourceMappingURL=source.d.ts.map

package/dist/components/Editor/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../../src/components/Editor/source.tsx"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAEtE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;CACf;AAED,kGAAkG;AAClG,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,EAAE,CAaxD;AAED,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAO3F;AAED,QAAA,MAAM,UAAU,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAMxC,CAAA;AAmCD,wBAAgB,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,+BAgB7E;AAED,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/components/RecordForm/RecordForm.config.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const recordFormConfigSchema: z.ZodObject<{
+    collection: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        required: z.ZodDefault<z.ZodBoolean>;
+        readOnly: z.ZodDefault<z.ZodBoolean>;
+        help: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>>;
+        min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        multiline: z.ZodDefault<z.ZodBoolean>;
+        users: z.ZodDefault<z.ZodEnum<{
+            members: "members";
+            free: "free";
+        }>>;
+        key: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            date: "date";
+            datetime: "datetime";
+            enum: "enum";
+            money: "money";
+            user: "user";
+        }>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    mode: z.ZodEnum<{
+        create: "create";
+        edit: "edit";
+    }>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        single: "single";
+        "two-column": "two-column";
+    }>>;
+    submitLabel: z.ZodDefault<z.ZodString>;
+    cancel: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        back: "back";
+    }>>;
+    successMessage: z.ZodDefault<z.ZodString>;
+    deleteAllowed: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type RecordFormConfig = z.output<typeof recordFormConfigSchema>;
+export type RecordFormConfigInput = z.input<typeof recordFormConfigSchema>;
+//# sourceMappingURL=RecordForm.config.d.ts.map

package/dist/components/RecordForm/RecordForm.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordForm.config.d.ts","sourceRoot":"","sources":["../../../src/components/RecordForm/RecordForm.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqF/B,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACtE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/components/RecordForm/RecordForm.d.ts

@@ -0,0 +1,96 @@
+import { type GolemProps } from '../../abi';
+import type { RecordRow } from '../../abi/fields';
+import { type IdentityAdapter, type RecordsAdapter } from '../../adapters';
+export interface RecordFormAdapters {
+    records: RecordsAdapter;
+    /** Read only for a `user` field whose choices come from `users: 'members'`. */
+    identity?: IdentityAdapter;
+}
+export interface RecordFormSlots {
+    /**
+     * The record `edit` mode loads and writes. The route knows it and the config does not, which is
+     * why it is a prop: one config serves every ticket on the board.
+     */
+    recordId?: string;
+    /** After a write has landed: the stored row, or `null` when the record was deleted. */
+    onDone?: (row: RecordRow | null) => void;
+    /** Cancel, once the reader has confirmed discarding whatever was unsaved. */
+    onCancel?: () => void;
+}
+export declare const RecordForm: import("react").FunctionComponent<GolemProps<{
+    collection: string;
+    fields: {
+        key: string;
+        label: string;
+        type: "number" | "boolean" | "text" | "date" | "datetime" | "enum" | "money" | "user";
+        required?: boolean | undefined;
+        readOnly?: boolean | undefined;
+        help?: string | undefined;
+        placeholder?: string | undefined;
+        options?: {
+            id: string;
+            label: string;
+        }[] | undefined;
+        min?: string | number | undefined;
+        max?: string | number | undefined;
+        multiline?: boolean | undefined;
+        users?: "members" | "free" | undefined;
+        format?: string | undefined;
+    }[];
+    mode: "create" | "edit";
+    layout?: "single" | "two-column" | undefined;
+    submitLabel?: string | undefined;
+    cancel?: "none" | "back" | undefined;
+    successMessage?: string | undefined;
+    deleteAllowed?: boolean | undefined;
+}, RecordFormAdapters, RecordFormSlots>> & {
+    schema: import("zod").ZodObject<{
+        collection: import("zod").ZodString;
+        fields: import("zod").ZodArray<import("zod").ZodObject<{
+            required: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            readOnly: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            help: import("zod").ZodOptional<import("zod").ZodString>;
+            placeholder: import("zod").ZodOptional<import("zod").ZodString>;
+            options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>>;
+            min: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>>;
+            max: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>>;
+            multiline: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            users: import("zod").ZodDefault<import("zod").ZodEnum<{
+                members: "members";
+                free: "free";
+            }>>;
+            key: import("zod").ZodString;
+            label: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                text: "text";
+                date: "date";
+                datetime: "datetime";
+                enum: "enum";
+                money: "money";
+                user: "user";
+            }>;
+            format: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+        mode: import("zod").ZodEnum<{
+            create: "create";
+            edit: "edit";
+        }>;
+        layout: import("zod").ZodDefault<import("zod").ZodEnum<{
+            single: "single";
+            "two-column": "two-column";
+        }>>;
+        submitLabel: import("zod").ZodDefault<import("zod").ZodString>;
+        cancel: import("zod").ZodDefault<import("zod").ZodEnum<{
+            none: "none";
+            back: "back";
+        }>>;
+        successMessage: import("zod").ZodDefault<import("zod").ZodString>;
+        deleteAllowed: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strict>;
+};
+//# sourceMappingURL=RecordForm.d.ts.map

package/dist/components/RecordForm/RecordForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordForm.d.ts","sourceRoot":"","sources":["../../../src/components/RecordForm/RecordForm.tsx"],"names":[],"mappings":"AAUA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AAC5D,OAAO,KAAK,EAAa,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAiB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAa,MAAM,gBAAgB,CAAA;AAcpG,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,cAAc,CAAA;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,eAAe,CAAA;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uFAAuF;IACvF,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAA;IACxC,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB;AAogBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQrB,CAAA"}

package/dist/components/RecordForm/RecordForm.docs.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentDocs } from '../../abi';
+export declare const recordFormDocs: ComponentDocs;
+//# sourceMappingURL=RecordForm.docs.d.ts.map

package/dist/components/RecordForm/RecordForm.docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordForm.docs.d.ts","sourceRoot":"","sources":["../../../src/components/RecordForm/RecordForm.docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,eAAO,MAAM,cAAc,EAAE,aA6J5B,CAAA"}

package/dist/components/RecordForm/index.d.ts

@@ -0,0 +1,6 @@
+export { RecordForm } from './RecordForm';
+export type { RecordFormAdapters, RecordFormSlots } from './RecordForm';
+export { recordFormConfigSchema } from './RecordForm.config';
+export type { RecordFormConfig, RecordFormConfigInput } from './RecordForm.config';
+export { recordFormDocs } from './RecordForm.docs';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/RecordForm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/RecordForm/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/components/RecordForm/values.d.ts

@@ -0,0 +1,26 @@
+import type { FormField, RecordRow } from '../../abi/fields';
+/** What an untouched control holds in create mode. A checkbox is off; everything else is blank. */
+export declare function blankValue(field: FormField): unknown;
+export declare function isEmpty(value: unknown): boolean;
+/**
+ * The record's value as the control shows it. `datetime` is the one that has to be reshaped: a
+ * record holds a full ISO instant and `datetime-local` takes minutes in UTC.
+ */
+export declare function toInput(value: unknown, field: FormField): string;
+/** The control's text as the record holds it. An empty control writes an empty string, never `0`. */
+export declare function fromInput(text: string, field: FormField): unknown;
+/**
+ * One field's complaint, or `null` when it is fine. The sentence is what the reader sees under the
+ * control, so it names the field the way its label does.
+ */
+export declare function validateField(field: FormField, value: unknown): string | null;
+/** Every editable field that fails, in the order the form shows them. */
+export declare function validateAll(fields: FormField[], values: RecordRow): {
+    key: string;
+    message: string;
+}[];
+/** Every editable field's value, which is what `create` sends: a new record has nothing to diff. */
+export declare function dataOf(fields: FormField[], values: RecordRow): RecordRow;
+/** What the reader actually changed. `readOnly` fields are never in it: the store owns them. */
+export declare function patchOf(fields: FormField[], values: RecordRow, initial: RecordRow): RecordRow;
+//# sourceMappingURL=values.d.ts.map

package/dist/components/RecordForm/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../../src/components/RecordForm/values.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAG5D,mGAAmG;AACnG,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEpD;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/C;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAOhE;AAED,qGAAqG;AACrG,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAYjE;AAQD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmB7E;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,EAAE,EACnB,MAAM,EAAE,SAAS,GAChB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,CAOpC;AAED,oGAAoG;AACpG,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,GAAG,SAAS,CAIxE;AAED,gGAAgG;AAChG,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,SAAS,CAO7F"}

package/dist/components/RecordList/RecordList.config.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const recordListConfigSchema: z.ZodObject<{
+    collection: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        primary: z.ZodDefault<z.ZodBoolean>;
+        key: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            date: "date";
+            datetime: "datetime";
+            enum: "enum";
+            money: "money";
+            user: "user";
+        }>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    sort: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strict>>;
+    scope: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>>;
+    filters: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    search: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    emptyState: z.ZodDefault<z.ZodString>;
+    rowAction: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        open: "open";
+    }>>;
+    density: z.ZodDefault<z.ZodEnum<{
+        compact: "compact";
+        comfortable: "comfortable";
+    }>>;
+}, z.core.$strict>;
+export type RecordListConfig = z.output<typeof recordListConfigSchema>;
+export type RecordListConfigInput = z.input<typeof recordListConfigSchema>;
+//# sourceMappingURL=RecordList.config.d.ts.map

package/dist/components/RecordList/RecordList.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordList.config.d.ts","sourceRoot":"","sources":["../../../src/components/RecordList/RecordList.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoG/B,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACtE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/components/RecordList/RecordList.d.ts

@@ -0,0 +1,76 @@
+import { type GolemProps } from '../../abi';
+import type { RecordsAdapter } from '../../adapters';
+import type { RecordRow } from '../../abi/fields';
+export type { RecordRow };
+export interface RecordListAdapters {
+    records: RecordsAdapter;
+}
+export interface RecordListSlots {
+    /**
+     * Where a row goes when it is opened — a click, Enter or Space. Only reached with
+     * `rowAction: 'open'`; the list has no router of its own, so the call site names the route.
+     */
+    onOpen?: (row: RecordRow) => void;
+}
+export declare const RecordList: import("react").FunctionComponent<GolemProps<{
+    collection: string;
+    fields: {
+        key: string;
+        label: string;
+        type: "number" | "boolean" | "text" | "date" | "datetime" | "enum" | "money" | "user";
+        primary?: boolean | undefined;
+        format?: string | undefined;
+    }[];
+    sort?: {
+        field: string;
+        direction: "asc" | "desc";
+    } | undefined;
+    scope?: Record<string, string | number | boolean | (string | number | boolean)[]> | undefined;
+    filters?: string[] | undefined;
+    search?: string[] | undefined;
+    pageSize?: number | undefined;
+    emptyState?: string | undefined;
+    rowAction?: "none" | "open" | undefined;
+    density?: "compact" | "comfortable" | undefined;
+}, RecordListAdapters, RecordListSlots>> & {
+    schema: import("zod").ZodObject<{
+        collection: import("zod").ZodString;
+        fields: import("zod").ZodArray<import("zod").ZodObject<{
+            primary: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            key: import("zod").ZodString;
+            label: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                text: "text";
+                date: "date";
+                datetime: "datetime";
+                enum: "enum";
+                money: "money";
+                user: "user";
+            }>;
+            format: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+        sort: import("zod").ZodOptional<import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            direction: import("zod").ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>;
+        }, import("zod/v4/core").$strict>>;
+        scope: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>]>>>;
+        filters: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        search: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        pageSize: import("zod").ZodDefault<import("zod").ZodNumber>;
+        emptyState: import("zod").ZodDefault<import("zod").ZodString>;
+        rowAction: import("zod").ZodDefault<import("zod").ZodEnum<{
+            none: "none";
+            open: "open";
+        }>>;
+        density: import("zod").ZodDefault<import("zod").ZodEnum<{
+            compact: "compact";
+            comfortable: "comfortable";
+        }>>;
+    }, import("zod/v4/core").$strict>;
+};
+//# sourceMappingURL=RecordList.d.ts.map

package/dist/components/RecordList/RecordList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordList.d.ts","sourceRoot":"","sources":["../../../src/components/RecordList/RecordList.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AAC5D,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEjE,OAAO,KAAK,EAAa,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAI5D,YAAY,EAAE,SAAS,EAAE,CAAA;AAEzB,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,CAAA;CAClC;AAifD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQrB,CAAA"}

package/dist/components/RecordList/RecordList.docs.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentDocs } from '../../abi';
+export declare const recordListDocs: ComponentDocs;
+//# sourceMappingURL=RecordList.docs.d.ts.map

package/dist/components/RecordList/RecordList.docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordList.docs.d.ts","sourceRoot":"","sources":["../../../src/components/RecordList/RecordList.docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,eAAO,MAAM,cAAc,EAAE,aAkH5B,CAAA"}

package/dist/components/RecordList/index.d.ts

@@ -0,0 +1,6 @@
+export { RecordList } from './RecordList';
+export type { RecordListAdapters, RecordListSlots, RecordRow } from './RecordList';
+export { recordListConfigSchema } from './RecordList.config';
+export type { RecordListConfig, RecordListConfigInput } from './RecordList.config';
+export { recordListDocs } from './RecordList.docs';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/RecordList/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/RecordList/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/components/Report/Report.config.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const reportConfigSchema: z.ZodObject<{
+    collection: z.ZodString;
+    period: z.ZodDefault<z.ZodEnum<{
+        month: "month";
+        week: "week";
+        day: "day";
+    }>>;
+    dateField: z.ZodDefault<z.ZodString>;
+    titleField: z.ZodDefault<z.ZodString>;
+    bodyField: z.ZodDefault<z.ZodString>;
+    statusField: z.ZodOptional<z.ZodString>;
+    authorField: z.ZodDefault<z.ZodString>;
+    showAuthor: z.ZodDefault<z.ZodBoolean>;
+    showIndex: z.ZodDefault<z.ZodBoolean>;
+    showNavigation: z.ZodDefault<z.ZodBoolean>;
+    print: z.ZodDefault<z.ZodBoolean>;
+    emptyState: z.ZodDefault<z.ZodString>;
+    locale: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type ReportConfig = z.output<typeof reportConfigSchema>;
+export type ReportConfigInput = z.input<typeof reportConfigSchema>;
+//# sourceMappingURL=Report.config.d.ts.map

package/dist/components/Report/Report.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.config.d.ts","sourceRoot":"","sources":["../../../src/components/Report/Report.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;kBA2F3B,CAAA;AAEJ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/components/Report/Report.d.ts

@@ -0,0 +1,53 @@
+import { type GolemProps } from '../../abi';
+import type { ClockAdapter, RecordsAdapter } from '../../adapters';
+export interface ReportAdapters {
+    records: RecordsAdapter;
+    clock: ClockAdapter;
+}
+export interface ReportSlots {
+    /**
+     * One report by id, instead of the latest of the current period. The component still opens on
+     * that report's period, so the arrows and the index carry on from where it sits.
+     */
+    id?: string;
+}
+/** One report record, as the component reads it: every field is named by the config. */
+export type ReportRecord = Record<string, unknown> & {
+    id: string;
+};
+export declare const Report: import("react").FunctionComponent<GolemProps<{
+    collection: string;
+    period?: "month" | "week" | "day" | undefined;
+    dateField?: string | undefined;
+    titleField?: string | undefined;
+    bodyField?: string | undefined;
+    statusField?: string | undefined;
+    authorField?: string | undefined;
+    showAuthor?: boolean | undefined;
+    showIndex?: boolean | undefined;
+    showNavigation?: boolean | undefined;
+    print?: boolean | undefined;
+    emptyState?: string | undefined;
+    locale?: string | undefined;
+}, ReportAdapters, ReportSlots>> & {
+    schema: import("zod").ZodObject<{
+        collection: import("zod").ZodString;
+        period: import("zod").ZodDefault<import("zod").ZodEnum<{
+            month: "month";
+            week: "week";
+            day: "day";
+        }>>;
+        dateField: import("zod").ZodDefault<import("zod").ZodString>;
+        titleField: import("zod").ZodDefault<import("zod").ZodString>;
+        bodyField: import("zod").ZodDefault<import("zod").ZodString>;
+        statusField: import("zod").ZodOptional<import("zod").ZodString>;
+        authorField: import("zod").ZodDefault<import("zod").ZodString>;
+        showAuthor: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        showIndex: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        showNavigation: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        print: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        emptyState: import("zod").ZodDefault<import("zod").ZodString>;
+        locale: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+};
+//# sourceMappingURL=Report.d.ts.map

package/dist/components/Report/Report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.d.ts","sourceRoot":"","sources":["../../../src/components/Report/Report.tsx"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAKlE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,EAAE,YAAY,CAAA;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ;AAED,wFAAwF;AACxF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAuYnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIjB,CAAA"}

package/dist/components/Report/Report.docs.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentDocs } from '../../abi';
+export declare const reportDocs: ComponentDocs;
+//# sourceMappingURL=Report.docs.d.ts.map

package/dist/components/Report/Report.docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.docs.d.ts","sourceRoot":"","sources":["../../../src/components/Report/Report.docs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,eAAO,MAAM,UAAU,EAAE,aAyIxB,CAAA"}

package/dist/components/Report/index.d.ts

@@ -0,0 +1,6 @@
+export { Report } from './Report';
+export type { ReportAdapters, ReportSlots, ReportRecord } from './Report';
+export { reportConfigSchema } from './Report.config';
+export type { ReportConfig, ReportConfigInput } from './Report.config';
+export { reportDocs } from './Report.docs';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Report/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Report/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACpD,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA"}

package/dist/components/Shell/Shell.config.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const shellConfigSchema: z.ZodObject<{
+    title: z.ZodString;
+    chatSide: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    breakpoint: z.ZodDefault<z.ZodNumber>;
+    showTopBar: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ShellConfig = z.output<typeof shellConfigSchema>;
+export type ShellConfigInput = z.input<typeof shellConfigSchema>;
+//# sourceMappingURL=Shell.config.d.ts.map

package/dist/components/Shell/Shell.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Shell.config.d.ts","sourceRoot":"","sources":["../../../src/components/Shell/Shell.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB;;;;;;;;kBAqBnB,CAAA;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}