@agentshouse/mdruntime-families 0.0.0-stage → 0.1.0-c043f1f493f7e

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton (trof3039)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# `@agentshouse/mdruntime-families`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+react-admin and Refine data providers over the
+[`@agentshouse/mdruntime`](https://www.npmjs.com/package/@agentshouse/mdruntime)
+client, so an App built on either framework reads and writes its Rooms.
+
+## Install
+
+```sh
+npm install @agentshouse/mdruntime-families @agentshouse/mdruntime
+```
+
+## Usage
+
+Each resource names the MD Type of its records and the folder they live in.
+A record's id is its Path in the Room, prefixed by the Room's locator and `/`
+when the App reaches several Rooms; a new record is created in the first.
+
+```ts
+import { QueryClient } from '@tanstack/react-query';
+import { dataProvider } from '@agentshouse/mdruntime-families/react-admin';
+
+const resources = { contacts: { type: 'contact', folder: 'contacts' } };
+const queryClient = new QueryClient();
+const provider = dataProvider(runtime, { resources, queryClient });
+// <Admin dataProvider={provider} queryClient={queryClient}>
+```
+
+```ts
+import { dataProvider, liveProvider } from '@agentshouse/mdruntime-families/refine';
+
+// <Refine dataProvider={dataProvider(runtime, { resources })}
+//   liveProvider={liveProvider(runtime, { resources })} options={{ liveMode: 'auto' }}>
+```
+
+`runtime` is the client the host hands the App. A filter or sort field such
+as `address.city` reads the value at `/address/city`. react-admin filters
+compare for equality, a list for membership, and the suffixes `_gt`, `_gte`,
+`_lt`, `_lte` and `_neq` compare as named; Refine filters take `eq`, `ne`,
+`lt`, `gt`, `lte`, `gte`, `in`, `nin`, `or` and `and`. A field the Room schema
+declares a reference, at any depth, holds the referenced record's id; `id` and
+a reference compare only for equality and membership. Pages and totals are
+counted over every matching record. react-admin's `update` writes the fields
+that differ from `previousData`, based on it, so the Save of a field another
+writer changed meanwhile is refused; Refine's `update` and either `updateMany`
+compare with the stored record. A list stays current: react-admin's queries of
+a resource are invalidated, and Refine's live mode refetches, when a document
+of the resource changes.
+
+## License
+
+MIT

package/dist/react-admin.d.ts

@@ -0,0 +1,15 @@
+import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
+import type { DataProvider } from 'ra-core';
+import { type Resources } from './records.js';
+export type { Resource, Resources } from './records.js';
+export type Invalidating = {
+    invalidateQueries(filters: {
+        queryKey: readonly unknown[];
+    }): Promise<unknown>;
+};
+export type DataProviderOptions = {
+    readonly resources: Resources;
+    readonly queryClient: Invalidating;
+};
+export declare function dataProvider(client: MdRuntimeClient, options: DataProviderOptions): DataProvider;
+//# sourceMappingURL=react-admin.d.ts.map

package/dist/react-admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-admin.d.ts","sourceRoot":"","sources":["../src/react-admin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAEV,YAAY,EAYb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAiD,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE7F,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,MAAM,YAAY,GAAG;IACzB,iBAAiB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAChF,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;CACpC,CAAC;AAiCF,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAoFhG"}

package/dist/react-admin.js

@@ -0,0 +1,80 @@
+import { records } from './records.js';
+const OPERATORS = [
+    ['_gte', '$gte'],
+    ['_gt', '$gt'],
+    ['_lte', '$lte'],
+    ['_lt', '$lt'],
+    ['_neq', '$ne'],
+];
+function clause(key, value) {
+    const list = Array.isArray(value);
+    const operator = OPERATORS.find(([suffix]) => key.endsWith(suffix));
+    if (operator === undefined)
+        return { field: key, operator: list ? '$in' : '$eq', value };
+    return {
+        field: key.slice(0, -operator[0].length),
+        operator: list && operator[1] === '$ne' ? '$nin' : operator[1],
+        value,
+    };
+}
+function paged(entries, pagination) {
+    if (pagination === undefined)
+        return [...entries];
+    const start = (pagination.page - 1) * pagination.perPage;
+    return entries.slice(start, start + pagination.perPage);
+}
+export function dataProvider(client, options) {
+    const held = records(client, options.resources);
+    const live = new Map();
+    function watched(resource) {
+        const known = live.get(resource);
+        if (known !== undefined)
+            return known;
+        const watching = held.watch(resource, () => {
+            void options.queryClient.invalidateQueries({ queryKey: [resource] });
+        });
+        live.set(resource, watching);
+        watching.catch(() => live.delete(resource));
+        return watching;
+    }
+    async function listed(resource, { filter, sort, pagination }) {
+        await watched(resource);
+        const named = Object.entries(filter ?? {});
+        const entries = await held.list(resource, named.length === 0 ? null : { every: named.map(([key, value]) => clause(key, value)) }, sort === undefined
+            ? []
+            : [{ field: sort.field, direction: sort.order === 'DESC' ? 'desc' : 'asc' }]);
+        return { data: paged(entries, pagination), total: entries.length };
+    }
+    return {
+        getList: async (resource, params) => (await listed(resource, params)),
+        getOne: async (resource, { id }) => {
+            await watched(resource);
+            return { data: await held.one(resource, id) };
+        },
+        getMany: async (resource, { ids }) => {
+            await watched(resource);
+            return { data: await held.many(resource, ids) };
+        },
+        getManyReference: async (resource, { target, id, filter, ...listing }) => (await listed(resource, {
+            ...listing,
+            filter: { ...filter, [target]: id },
+        })),
+        create: async (resource, { data }) => ({ data: await held.create(resource, data) }),
+        update: async (resource, { id, data, previousData }) => {
+            const [entry] = await held.update(resource, [id], data, previousData);
+            return { data: entry };
+        },
+        updateMany: async (resource, { ids, data }) => {
+            await held.update(resource, ids, data, null);
+            return { data: ids };
+        },
+        delete: async (resource, { id }) => {
+            const [entry] = await held.remove(resource, [id]);
+            return { data: entry };
+        },
+        deleteMany: async (resource, { ids }) => {
+            await held.remove(resource, ids);
+            return { data: ids };
+        },
+    };
+}

package/dist/records.d.ts

@@ -0,0 +1,36 @@
+import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
+export type Resource = {
+    readonly type: string;
+    readonly folder: string;
+};
+export type Resources = Readonly<Record<string, Resource>>;
+export type Key = string | number;
+export type Fields = Readonly<Record<string, unknown>>;
+export type Entry = {
+    readonly id: string;
+    readonly [field: string]: unknown;
+};
+export type Order = {
+    readonly field: string;
+    readonly direction: 'asc' | 'desc';
+};
+export type Operator = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin';
+export type Clause = {
+    readonly every: readonly Clause[];
+} | {
+    readonly some: readonly Clause[];
+} | {
+    readonly field: string;
+    readonly operator: Operator;
+    readonly value: unknown;
+};
+export declare function records(client: MdRuntimeClient, resources: Resources): {
+    list(name: string, clause: Clause | null, order: readonly Order[]): Promise<Entry[]>;
+    many(name: string, ids: readonly Key[]): Promise<Entry[]>;
+    one(name: string, id: Key): Promise<Entry>;
+    create(name: string, data: Fields): Promise<Entry>;
+    update(name: string, ids: readonly Key[], data: Fields, shown: Fields | null): Promise<Entry[]>;
+    remove(name: string, ids: readonly Key[]): Promise<Entry[]>;
+    watch(name: string, heard: () => void): Promise<() => void>;
+};
+//# sourceMappingURL=records.d.ts.map

package/dist/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../src/records.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGrE,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1E,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;AAE3D,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,MAAM,CAAC;AAElC,MAAM,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEvD,MAAM,MAAM,KAAK,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,KAAK,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAA;CAAE,CAAC;AAEnF,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAExF,MAAM,MAAM,MAAM,GACd;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACrC;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACpC;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AA6KrF,wBAAgB,OAAO,CAAC,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS;IA+I3D,IAAI,OAAO,MAAM,UAAU,MAAM,GAAG,IAAI,SAAS,SAAS,KAAK,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAcpF,IAAI,OAAO,MAAM,OAAO,SAAS,GAAG,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAOzD,GAAG,OAAO,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC;IAM1C,MAAM,OAAO,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAiBlD,MAAM,OACJ,MAAM,OACP,SAAS,GAAG,EAAE,QACb,MAAM,SACL,MAAM,GAAG,IAAI,GACnB,OAAO,CAAC,KAAK,EAAE,CAAC;IAab,MAAM,OAAO,MAAM,OAAO,SAAS,GAAG,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAiB3D,KAAK,OAAO,MAAM,SAAS,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC;EAWpE"}

package/dist/records.js

@@ -0,0 +1,329 @@
+import { ARRAY_INDEX, escapePointer, itemFacts, memberFacts, pointerSegments, references, relative, target, } from '@agentshouse/mdmodel';
+import { saveRoomDrafts } from '@agentshouse/mdruntime/react';
+const FIELDS = { fields: 'all' };
+const REMOVABLE = { fields: 'all', markdown: true };
+const BY_ID = [{ field: 'id', direction: 'asc' }];
+const RESERVED = new Set(['id', 'type']);
+const EQUALITY = {
+    $eq: true,
+    $in: true,
+    $ne: false,
+    $nin: false,
+};
+function pointer(field) {
+    return field
+        .split('.')
+        .map((segment) => `/${escapePointer(segment)}`)
+        .join('');
+}
+function listed(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function same(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (typeof left !== 'object' || typeof right !== 'object' || left === null || right === null) {
+        return false;
+    }
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    const named = Object.keys(left);
+    return (named.length === Object.keys(right).length &&
+        named.every((name) => same(left[name], right[name])));
+}
+function factsAt(facts, field) {
+    let reached = facts;
+    for (const segment of field.split('.')) {
+        if (reached?.type === 'array' && ARRAY_INDEX.test(segment)) {
+            reached = itemFacts(reached, Number(segment));
+            continue;
+        }
+        while (reached?.type === 'array')
+            reached = reached.items;
+        reached = reached === undefined ? undefined : memberFacts(reached, segment);
+    }
+    return reached;
+}
+function referring(facts) {
+    return facts?.reference !== undefined || facts?.items?.reference !== undefined;
+}
+function relinked(fields, definition, each) {
+    const copy = structuredClone(fields);
+    if (definition === undefined)
+        return copy;
+    const document = { content: '', type: undefined, fields, preamble: '', sections: {} };
+    for (const { pointer, value } of references(document, definition)) {
+        const segments = pointerSegments(pointer);
+        const last = segments.pop();
+        let held = copy;
+        for (const segment of segments)
+            held = held[segment];
+        if (last !== undefined)
+            held[last] = each(value);
+    }
+    return copy;
+}
+function idOf(shelf, room, path) {
+    return shelf.rooms.length > 1 ? `${room}/${path}` : path;
+}
+function keyOf(shelf, document) {
+    return idOf(shelf, document.room, document.path);
+}
+function placeOf(shelf, id) {
+    const text = String(id);
+    if (shelf.rooms.length > 1) {
+        const cut = text.indexOf('/');
+        if (cut <= 0)
+            throw new Error(`${text} names no Room`);
+        return { room: text.slice(0, cut), path: text.slice(cut + 1) };
+    }
+    const [room] = shelf.rooms;
+    if (room === undefined)
+        throw new Error('no Room is reached');
+    return { room, path: text };
+}
+function equality(field, operator) {
+    const equal = EQUALITY[operator];
+    if (equal === undefined)
+        throw new Error(`${field} compares only for equality`);
+    return equal;
+}
+function sorting(shelf, { field, direction }) {
+    if (field !== 'id')
+        return [{ by: { field: pointer(field) }, direction }];
+    const path = { by: 'path', direction };
+    return shelf.rooms.length > 1 ? [{ by: 'room', direction }, path] : [path];
+}
+function entryOf(shelf, document) {
+    const fields = Object.fromEntries(Object.entries(document.fields ?? {}).filter(([field]) => !RESERVED.has(field)));
+    const read = relinked(fields, shelf.definitions.get(document.room), (link) => {
+        const found = target(document.path, link);
+        return found === null ? link : idOf(shelf, document.room, found);
+    });
+    return { ...read, id: keyOf(shelf, document) };
+}
+function written(shelf, place, field, value) {
+    return relinked({ [field]: value }, shelf.definitions.get(place.room), (id) => {
+        const to = placeOf(shelf, id);
+        if (to.room !== place.room)
+            throw new Error(`${field} names a record in another Room`);
+        return relative(place.path, to.path);
+    })[field];
+}
+function changed(shelf, { place, document }, data, shown) {
+    const current = entryOf(shelf, document);
+    const prior = shown ?? current;
+    const stored = document.fields ?? {};
+    const fields = {};
+    for (const [field, value] of Object.entries(data)) {
+        if (RESERVED.has(field) || value === undefined || same(value, prior[field]))
+            continue;
+        const base = same(prior[field], current[field])
+            ? Object.hasOwn(stored, field)
+                ? { value: stored[field] }
+                : null
+            : prior[field] === undefined
+                ? null
+                : { value: written(shelf, place, field, prior[field]) };
+        fields[field] = { value: written(shelf, place, field, value), base };
+    }
+    return Object.keys(fields).length === 0 ? null : { fields };
+}
+function byRoom(items) {
+    const rooms = new Map();
+    for (const item of items) {
+        rooms.set(item.place.room, [...(rooms.get(item.place.room) ?? []), item]);
+    }
+    return rooms;
+}
+export function records(client, resources) {
+    function resourceOf(name) {
+        const resource = Object.hasOwn(resources, name) ? resources[name] : undefined;
+        if (resource === undefined)
+            throw new Error(`${name} is not a configured resource`);
+        return resource;
+    }
+    async function shelfOf(name) {
+        const resource = resourceOf(name);
+        const rooms = (await client.rooms()).map((room) => room.locator);
+        const definitions = new Map();
+        for (const room of rooms) {
+            const schema = (await client.types(room)).collection;
+            if (schema.status === 'unavailable')
+                continue;
+            const definition = schema.types.find((type) => type.name === resource.type);
+            if (definition === undefined)
+                continue;
+            definitions.set(room, definition);
+        }
+        return { resource, rooms, definitions };
+    }
+    async function keys(shelf, query) {
+        const { documents } = await client.query({
+            ...query,
+            types: [shelf.resource.type],
+            pathPrefix: shelf.resource.folder,
+            select: {},
+        });
+        return new Set(documents.map((document) => keyOf(shelf, document)));
+    }
+    async function referenced(shelf, field, places) {
+        const kept = new Set();
+        for (const room of shelf.rooms) {
+            const paths = places.flatMap((place) => place === null ? [null] : place.room === room ? [place.path] : []);
+            const definition = shelf.definitions.get(room);
+            if (paths.length === 0 || !referring(factsAt(definition?.frontmatter, field)))
+                continue;
+            const where = { [pointer(field)]: { $in: paths } };
+            for (const key of await keys(shelf, { rooms: [room], where }))
+                kept.add(key);
+        }
+        return kept;
+    }
+    async function matching(shelf, all, clause) {
+        if ('every' in clause) {
+            let kept = new Set(all.map((document) => keyOf(shelf, document)));
+            for (const one of clause.every) {
+                const next = await matching(shelf, all, one);
+                kept = new Set([...kept].filter((key) => next.has(key)));
+            }
+            return kept;
+        }
+        if ('some' in clause) {
+            const kept = new Set();
+            for (const one of clause.some) {
+                for (const key of await matching(shelf, all, one))
+                    kept.add(key);
+            }
+            return kept;
+        }
+        const { field, operator, value } = clause;
+        const reference = [...shelf.definitions.values()].some((definition) => referring(factsAt(definition.frontmatter, field)));
+        if (field !== 'id' && !reference) {
+            return keys(shelf, { where: { [pointer(field)]: { [operator]: value } } });
+        }
+        const equal = equality(field, operator);
+        const places = listed(value).map((id) => (id === null ? null : placeOf(shelf, id)));
+        const matched = field === 'id'
+            ? new Set(places.flatMap((place) => place === null ? [] : [idOf(shelf, place.room, place.path)]))
+            : await referenced(shelf, field, places);
+        return new Set(all.map((document) => keyOf(shelf, document)).filter((key) => matched.has(key) === equal));
+    }
+    async function found(shelf, ids, select) {
+        const places = ids.map((id) => placeOf(shelf, id));
+        const documents = new Map();
+        for (const room of new Set(places.map((place) => place.room))) {
+            const answer = await client.query({
+                rooms: [room],
+                types: [shelf.resource.type],
+                pathPrefix: shelf.resource.folder,
+                select,
+            });
+            for (const document of answer.documents)
+                documents.set(keyOf(shelf, document), document);
+        }
+        return places.map((place) => ({
+            place,
+            document: documents.get(idOf(shelf, place.room, place.path)) ?? null,
+        }));
+    }
+    async function held(shelf, ids, select) {
+        return (await found(shelf, ids, select)).map(({ place, document }) => {
+            if (document === null)
+                throw new Error(`no ${shelf.resource.type} is held at ${place.path}`);
+            return { place, document };
+        });
+    }
+    async function dropped(room, paths) {
+        for (const path of paths) {
+            const left = await client.roomDraft.read(room, path);
+            if (left !== null)
+                await client.roomDraft.discard(room, path, left.revision);
+        }
+    }
+    async function saved(room, parts) {
+        if (parts.size === 0)
+            return;
+        const result = await saveRoomDrafts(client, room, parts).catch(async (error) => {
+            await dropped(room, parts.keys());
+            throw error;
+        });
+        if (result.outcome === 'refused') {
+            await dropped(room, parts.keys());
+            throw new Error(`the Save was refused as ${result.rule}`, { cause: result });
+        }
+    }
+    return {
+        async list(name, clause, order) {
+            const shelf = await shelfOf(name);
+            const { documents } = await client.query({
+                types: [shelf.resource.type],
+                pathPrefix: shelf.resource.folder,
+                orderBy: (order.length === 0 ? BY_ID : order).flatMap((one) => sorting(shelf, one)),
+                select: FIELDS,
+            });
+            const kept = clause === null ? null : await matching(shelf, documents, clause);
+            return documents
+                .filter((document) => kept === null || kept.has(keyOf(shelf, document)))
+                .map((document) => entryOf(shelf, document));
+        },
+        async many(name, ids) {
+            const shelf = await shelfOf(name);
+            return (await found(shelf, ids, FIELDS)).flatMap(({ document }) => document === null ? [] : [entryOf(shelf, document)]);
+        },
+        async one(name, id) {
+            const shelf = await shelfOf(name);
+            const [{ document }] = await held(shelf, [id], FIELDS);
+            return entryOf(shelf, document);
+        },
+        async create(name, data) {
+            const shelf = await shelfOf(name);
+            const [room] = shelf.rooms;
+            if (room === undefined)
+                throw new Error('no Room is reached');
+            const file = `${crypto.randomUUID()}.md`;
+            const { type, folder } = shelf.resource;
+            const place = { room, path: folder === '' ? file : `${folder}/${file}` };
+            const fields = Object.fromEntries(Object.entries(data)
+                .filter(([field, value]) => !RESERVED.has(field) && value !== undefined)
+                .map(([field, value]) => [field, written(shelf, place, field, value)]));
+            await saved(room, new Map([[place.path, { creation: { type, fields, sections: {} } }]]));
+            const [{ document }] = await held(shelf, [idOf(shelf, room, place.path)], FIELDS);
+            return entryOf(shelf, document);
+        },
+        async update(name, ids, data, shown) {
+            const shelf = await shelfOf(name);
+            for (const [room, inRoom] of byRoom(await held(shelf, ids, FIELDS))) {
+                const parts = new Map();
+                for (const one of inRoom) {
+                    const part = changed(shelf, one, data, shown);
+                    if (part !== null)
+                        parts.set(one.place.path, part);
+                }
+                await saved(room, parts);
+            }
+            return (await held(shelf, ids, FIELDS)).map(({ document }) => entryOf(shelf, document));
+        },
+        async remove(name, ids) {
+            const shelf = await shelfOf(name);
+            const removed = await held(shelf, ids, REMOVABLE);
+            for (const [room, inRoom] of byRoom(removed)) {
+                await saved(room, new Map(inRoom.map(({ place, document }) => [
+                    place.path,
+                    { removal: { base: document.markdown ?? null } },
+                ])));
+            }
+            return removed.map(({ document }) => entryOf(shelf, document));
+        },
+        async watch(name, heard) {
+            const { type, folder } = resourceOf(name);
+            const observation = await client.observe('query', {
+                types: [type],
+                pathPrefix: folder,
+                select: { markdown: true },
+            });
+            observation.subscribe(heard);
+            return () => observation.close();
+        },
+    };
+}

package/dist/refine.d.ts

@@ -0,0 +1,10 @@
+import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
+import type { DataProvider, LiveProvider } from '@refinedev/core';
+import { type Resources } from './records.js';
+export type { Resource, Resources } from './records.js';
+export type ProviderOptions = {
+    readonly resources: Resources;
+};
+export declare function dataProvider(client: MdRuntimeClient, options: ProviderOptions): DataProvider;
+export declare function liveProvider(client: MdRuntimeClient, options: ProviderOptions): LiveProvider;
+//# sourceMappingURL=refine.d.ts.map

package/dist/refine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refine.d.ts","sourceRoot":"","sources":["../src/refine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAMV,YAAY,EAMZ,YAAY,EAIb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAML,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAAE,CAAC;AAgChE,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe,GAAG,YAAY,CAgF5F;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe,GAAG,YAAY,CAW5F"}

package/dist/refine.js

@@ -0,0 +1,66 @@
+import { records, } from './records.js';
+const OPERATORS = {
+    eq: '$eq',
+    ne: '$ne',
+    lt: '$lt',
+    gt: '$gt',
+    lte: '$lte',
+    gte: '$gte',
+    in: '$in',
+    nin: '$nin',
+};
+function clause(filter) {
+    if (!('field' in filter)) {
+        const each = filter.value.map(clause);
+        return filter.operator === 'or' ? { some: each } : { every: each };
+    }
+    const operator = Object.hasOwn(OPERATORS, filter.operator)
+        ? OPERATORS[filter.operator]
+        : undefined;
+    if (operator === undefined)
+        throw new Error(`the ${filter.operator} filter has no condition`);
+    return { field: filter.field, operator, value: filter.value };
+}
+function paged(entries, pagination) {
+    const { currentPage = 1, pageSize = 10, mode = 'server' } = pagination ?? {};
+    if (mode !== 'server')
+        return [...entries];
+    const start = (currentPage - 1) * pageSize;
+    return entries.slice(start, start + pageSize);
+}
+export function dataProvider(client, options) {
+    const held = records(client, options.resources);
+    return {
+        getList: async ({ resource, filters, sorters, pagination, }) => {
+            const entries = await held.list(resource, filters === undefined || filters.length === 0 ? null : { every: filters.map(clause) }, (sorters ?? []).map(({ field, order }) => ({ field, direction: order })));
+            return { data: paged(entries, pagination), total: entries.length };
+        },
+        getMany: async ({ resource, ids, }) => ({ data: await held.many(resource, ids) }),
+        getOne: async ({ resource, id }) => ({ data: await held.one(resource, id) }),
+        create: async ({ resource, variables, }) => ({ data: await held.create(resource, variables) }),
+        update: async ({ resource, id, variables, }) => {
+            const [entry] = await held.update(resource, [id], variables, null);
+            return { data: entry };
+        },
+        updateMany: async ({ resource, ids, variables, }) => ({
+            data: await held.update(resource, ids, variables, null),
+        }),
+        deleteOne: async ({ resource, id, }) => {
+            const [entry] = await held.remove(resource, [id]);
+            return { data: entry };
+        },
+        deleteMany: async ({ resource, ids, }) => ({ data: await held.remove(resource, ids) }),
+        getApiUrl: () => '',
+    };
+}
+export function liveProvider(client, options) {
+    const held = records(client, options.resources);
+    return {
+        subscribe: ({ channel, params, callback }) => held.watch(String(params?.resource), () => {
+            callback({ channel, type: '*', payload: {}, date: new Date() });
+        }),
+        unsubscribe: (subscription) => {
+            void subscription.then((close) => close());
+        },
+    };
+}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@agentshouse/mdruntime-families",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-c043f1f493f7e",
+  "description": "react-admin and Refine data providers over the MD Runtime client",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24.21.0"
+  },
+  "exports": {
+    "./react-admin": {
+      "types": "./dist/react-admin.d.ts",
+      "import": "./dist/react-admin.js"
+    },
+    "./refine": {
+      "types": "./dist/refine.d.ts",
+      "import": "./dist/refine.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@agentshouse/mdmodel": "0.1.0-c896b3d9398b1",
+    "@agentshouse/mdruntime": "0.1.0-c389df724fd2f"
+  },
+  "peerDependencies": {
+    "@refinedev/core": ">=5",
+    "ra-core": ">=5",
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@refinedev/core": {
+      "optional": true
+    },
+    "ra-core": {
+      "optional": true
+    }
+  }
+}