@sincpro/web-framework 0.0.0-stage → 0.2.0

package/dist/core/copy.js

@@ -0,0 +1,141 @@
+export const ENGLISH_FRAMEWORK_COPY = {
+    value: {
+        yes: "yes",
+        no: "no",
+        items: (count, exact) => `${count}${exact ? "" : "+"} ${count === 1 ? "item" : "items"}`,
+    },
+    list: {
+        loadMore: "Load more",
+        loading: "Loading…",
+        shown: (shown, total, exact) => `${shown} of ${total}${exact ? "" : "+"}`,
+        empty: "Nothing here yet.",
+        emptyFiltered: "Nothing matches.",
+        search: "Search",
+        searchBar: "Search, or # to pick a field…",
+        builder: "Criteria builder",
+        capped: (shown) => `Showing the first ${shown}. Narrow the search to see the rest.`,
+        dropped: (fields) => `The server ignored a condition on ${fields.join(", ")}: the list shows more than asked.`,
+        noValue: "No value",
+        groupsCapped: (shown) => `The first ${shown} groups. Narrow the search to see the rest.`,
+        groups: (groups, records) => `${groups} ${groups === 1 ? "group" : "groups"} · ${records} ${records === 1 ? "record" : "records"}`,
+    },
+    record: {
+        restored: "A draft you kept is back. Save it or discard it.",
+        conflict: "Someone saved this record after you opened it. Nothing was overwritten: read it again.",
+        reload: "Read it again",
+        missing: (fields) => `Missing: ${fields.join(", ")}.`,
+        keep: "Keep draft",
+        loading: "Loading the record",
+        partial: (shown, total) => `Showing ${shown} of ${total}.`,
+        creating: (name) => (name ? `${name} · new` : "New"),
+        create: "New",
+    },
+    picker: {
+        browse: "Search all",
+    },
+    summary: {
+        created: "Created",
+        updated: "Updated",
+        when: (at, by) => (by === null ? at : `${at} · ${by}`),
+        updatedLine: (at, by) => (by === null ? `Updated ${at}` : `Updated ${at} by ${by}`),
+        createdLine: (at, by) => (by === null ? `Created ${at}` : `Created ${at} by ${by}`),
+    },
+    command: {
+        confirm: "Do it",
+        cancel: "Cancel",
+        rehearsing: "Checking what it would do…",
+    },
+    failure: {
+        unreachable: "The server could not be reached",
+        status: (status) => `The server answered ${status}`,
+        retry: "Retry",
+        kind: {
+            invalid: "The request is not valid",
+            unauthenticated: "Sign in again",
+            permission_denied: "You do not have access",
+            not_found: "It does not exist",
+            conflict: "Someone changed it first",
+            in_progress: "It is still in progress",
+            key_reused: "That request was already sent",
+            domain: "The operation was refused",
+            exhausted: "Too many requests",
+            unavailable: "The service is not available",
+            unknown_outcome: "It is not known whether it was done",
+            internal: "Something failed on the server",
+        },
+    },
+};
+export const SPANISH_FRAMEWORK_COPY = {
+    value: {
+        yes: "sí",
+        no: "no",
+        items: (count, exact) => `${count}${exact ? "" : "+"} ${count === 1 ? "elemento" : "elementos"}`,
+    },
+    list: {
+        loadMore: "Cargar más",
+        loading: "Cargando…",
+        shown: (shown, total, exact) => `${shown} de ${total}${exact ? "" : "+"}`,
+        empty: "Todavía no hay nada.",
+        emptyFiltered: "Nada coincide.",
+        search: "Buscar",
+        searchBar: "Buscar, o # para elegir el campo…",
+        builder: "Constructor de criteria",
+        capped: (shown) => `Se muestran los primeros ${shown}. Refiná la búsqueda para ver el resto.`,
+        dropped: (fields) => `El servidor ignoró una condición sobre ${fields.join(", ")}: la lista muestra más de lo pedido.`,
+        noValue: "Sin valor",
+        groupsCapped: (shown) => `Los primeros ${shown} grupos. Acotá la búsqueda para ver el resto.`,
+        groups: (groups, records) => `${groups} ${groups === 1 ? "grupo" : "grupos"} · ${records} ${records === 1 ? "registro" : "registros"}`,
+    },
+    record: {
+        restored: "Volvió un borrador que guardaste. Guardalo o descartalo.",
+        conflict: "Alguien guardó este registro después de que lo abriste. No se pisó nada: volvé a leerlo.",
+        reload: "Volver a leer",
+        missing: (fields) => `Falta: ${fields.join(", ")}.`,
+        keep: "Guardar borrador",
+        loading: "Cargando el registro",
+        partial: (shown, total) => `Se muestran ${shown} de ${total}.`,
+        creating: (name) => (name ? `${name} · nuevo` : "Nuevo"),
+        create: "Nuevo",
+    },
+    picker: {
+        browse: "Buscar en todos",
+    },
+    summary: {
+        created: "Creado",
+        updated: "Actualizado",
+        when: (at, by) => (by === null ? at : `${at} · ${by}`),
+        updatedLine: (at, by) => by === null ? `Actualizado el ${at}` : `Actualizado el ${at} por ${by}`,
+        createdLine: (at, by) => (by === null ? `Creado el ${at}` : `Creado el ${at} por ${by}`),
+    },
+    command: {
+        confirm: "Hacerlo",
+        cancel: "Cancelar",
+        rehearsing: "Revisando qué haría…",
+    },
+    failure: {
+        unreachable: "No se pudo hablar con el servidor",
+        status: (status) => `El servidor respondió ${status}`,
+        retry: "Reintentar",
+        kind: {
+            invalid: "El pedido no es válido",
+            unauthenticated: "Volvé a iniciar sesión",
+            permission_denied: "No tenés acceso",
+            not_found: "No existe",
+            conflict: "Alguien lo cambió antes",
+            in_progress: "Todavía está en curso",
+            key_reused: "Ese pedido ya se envió",
+            domain: "La operación fue rechazada",
+            exhausted: "Demasiados pedidos",
+            unavailable: "El servicio no está disponible",
+            unknown_outcome: "No se sabe si se hizo",
+            internal: "Algo falló en el servidor",
+        },
+    },
+};
+let installed = ENGLISH_FRAMEWORK_COPY;
+/** Install the framework's words once, where the application starts. */
+export function installFrameworkCopy(copy) {
+    installed = copy;
+}
+/** The words in use. A plain read: they are installed before anything draws. */
+export const frameworkCopy = () => installed;

package/dist/core/edit.d.ts

@@ -0,0 +1,40 @@
+import { type AnyRecord, type FieldError, type Meta } from "@sincpro/criteria";
+/**
+ * What an edit is, as plain functions: the state of each field and what changed.
+ *
+ * Context: sincpro_framework publishes form HINTS on each field — `readonly`, `required`, and
+ * `readonly_when` / `required_when` / `visible_when` as criteria conditions over the record —
+ * and says they are evaluated «with the same evaluator a client filters with». So a field's
+ * state is `matches(values, condition, meta)` over what is on screen NOW: typing «card» in the
+ * payment makes «card reference» required at once, with no round trip. A `Preview` from the
+ * server, when the entity has one, refines it — the server's word wins.
+ *
+ * Hints are defaults for a screen, never protection: the server keeps whatever rule matters.
+ */
+export type FieldState = {
+    readonly: boolean;
+    required: boolean;
+    visible: boolean;
+};
+/** What a server preview said about a field. */
+export type FieldStates = Readonly<Record<string, Partial<FieldState>>>;
+export declare function fieldStateOf(meta: Meta | null | undefined, name: string, values: AnyRecord, fromServer?: FieldStates): FieldState;
+/** The fields whose value differs from the record's — what a save or a draft sends. */
+export declare function changesOf(record: AnyRecord, values: AnyRecord): AnyRecord;
+/** What is missing before it can be saved: a required, visible, editable field left empty. */
+export declare function missingOf(meta: Meta | null | undefined, values: AnyRecord, fromServer?: FieldStates): string[];
+/** The server's word on a field that did not validate: `errors[].pointer` is a JSON pointer. */
+export declare function errorsByField(errors: readonly FieldError[] | undefined): Record<string, string>;
+/**
+ * A record that does not exist yet: the defaults the model publishes for each field
+ * (`FieldMeta.default`, sincpro_framework's `defaults_of`), and nothing else.
+ *
+ *     defaultsOf(invoiceMeta)  ->  { state: "draft", payment: "cash", discount: "0" }
+ */
+export declare function defaultsOf(meta: Meta | null | undefined): AnyRecord;
+/**
+ * What a create sends: every value on screen the caller may write. A field the model marks
+ * `readonly` is the server's to fill (the number, the totals), and an empty one is left for
+ * the server's own default — never sent as `""`.
+ */
+export declare function creationOf(meta: Meta | null | undefined, values: AnyRecord): AnyRecord;

package/dist/core/edit.js

@@ -0,0 +1,81 @@
+import { matches, } from "@sincpro/criteria";
+function holds(values, condition, meta) {
+    if (condition === null || condition === undefined)
+        return false;
+    return matches(values, condition, meta);
+}
+export function fieldStateOf(meta, name, values, fromServer) {
+    const field = meta?.fields[name];
+    const own = field === undefined || meta == null
+        ? { readonly: false, required: false, visible: true }
+        : {
+            readonly: (field.readonly ?? false) || holds(values, field.readonly_when, meta),
+            required: (field.required ?? false) || holds(values, field.required_when, meta),
+            visible: field.visible_when === null || field.visible_when === undefined
+                ? true
+                : holds(values, field.visible_when, meta),
+        };
+    return { ...own, ...fromServer?.[name] };
+}
+/** The fields whose value differs from the record's — what a save or a draft sends. */
+export function changesOf(record, values) {
+    const changed = {};
+    for (const [name, value] of Object.entries(values))
+        if (JSON.stringify(value) !== JSON.stringify(record[name]))
+            changed[name] = value;
+    return changed;
+}
+/** What is missing before it can be saved: a required, visible, editable field left empty. */
+export function missingOf(meta, values, fromServer) {
+    if (!meta)
+        return [];
+    return Object.keys(meta.fields).filter((name) => {
+        const state = fieldStateOf(meta, name, values, fromServer);
+        const value = values[name];
+        const empty = value === null ||
+            value === undefined ||
+            value === "" ||
+            (Array.isArray(value) && value.length === 0);
+        return state.required && state.visible && !state.readonly && empty;
+    });
+}
+/** The server's word on a field that did not validate: `errors[].pointer` is a JSON pointer. */
+export function errorsByField(errors) {
+    const found = {};
+    for (const error of errors ?? []) {
+        const name = error.pointer.replace(/^\/(values\/)?/, "").split("/")[0] ?? "";
+        if (name !== "" && found[name] === undefined)
+            found[name] = error.detail;
+    }
+    return found;
+}
+/**
+ * A record that does not exist yet: the defaults the model publishes for each field
+ * (`FieldMeta.default`, sincpro_framework's `defaults_of`), and nothing else.
+ *
+ *     defaultsOf(invoiceMeta)  ->  { state: "draft", payment: "cash", discount: "0" }
+ */
+export function defaultsOf(meta) {
+    const values = {};
+    for (const [name, field] of Object.entries(meta?.fields ?? {}))
+        if (field.default !== null && field.default !== undefined)
+            values[name] = field.default;
+    return values;
+}
+/**
+ * What a create sends: every value on screen the caller may write. A field the model marks
+ * `readonly` is the server's to fill (the number, the totals), and an empty one is left for
+ * the server's own default — never sent as `""`.
+ */
+export function creationOf(meta, values) {
+    const sent = {};
+    for (const [name, value] of Object.entries(values)) {
+        const field = meta?.fields[name];
+        if (field?.readonly === true)
+            continue;
+        if (value === undefined || value === null || value === "")
+            continue;
+        sent[name] = value;
+    }
+    return sent;
+}

package/dist/core/entity.d.ts

@@ -0,0 +1,113 @@
+import type { AnyRecord } from "@sincpro/criteria";
+import type { SummaryFields } from "./summary.js";
+import type { Method } from "./transport.js";
+/**
+ * Everything a screen needs to know about where an entity lives on the server, declared once.
+ *
+ * Context: a screen should not know a URL. It names the entity, and the entity says where its
+ * list is, where one record is, which Commands it takes, how it is saved and previewed, where a
+ * draft is kept and where its history is. `key` is how the workspace refers to it
+ * (`domain:kind`, the shape of a composer `ResourceRef`).
+ *
+ * The routes are declared, not guessed: sincpro_framework publishes a route per use case and
+ * its model definition does not list them (yet). A route is `"METHOD /path/{id}"` for a write.
+ *
+ *     export const invoices = entity<Invoice>("billing:invoice", {
+ *       list: "/invoices",
+ *       create: "POST /invoices",
+ *       save: "PUT /invoices/{id}",
+ *       preview: "POST /invoices/preview",
+ *       commands: { confirm: "POST /invoices/{id}/confirm", cancel: "POST /invoices/{id}/cancel" },
+ *       history: { route: "/billing-events", type: "Invoice" },
+ *     });
+ */
+export type Entity<T extends AnyRecord = AnyRecord> = {
+    /** `domain:kind`, e.g. `"billing:invoice"`. */
+    key: string;
+    domain: string;
+    kind: string;
+    /** Where the workspace finds it: the list without an id, one record with it — the shape of a
+     *  composer `ResourceRef`, built here so no screen writes `{ domain, kind, id }` by hand. */
+    ref: (id?: string) => EntityRef;
+    /** A record that does not exist yet — the form that creates one. Its view is the record's. */
+    newRef: () => EntityRef;
+    /** Its list opened to CHOOSE one: a row answers whoever asked (composer's `api.pick`). With
+     *  `query`, the list opens on that literal search — what was typed in the picker. */
+    chooserRef: (query?: string) => EntityRef;
+    /** The route of its list. */
+    list: string;
+    /** The route of one record. */
+    one: (id: string) => string;
+    /** Its Commands, by name. */
+    commands: Readonly<Record<string, WriteRoute>>;
+    /** How a new record is created: the list's own route, usually. */
+    create?: WriteRoute;
+    /** How an edit is saved: the record's own route with `{id}`. */
+    save?: WriteRoute;
+    /** «What does this record become?» before saving — sincpro_framework's `Preview`. */
+    preview?: WriteRoute;
+    /** Where this caller keeps an edit between requests — sincpro_framework's `Drafts`. */
+    draft?: WriteRoute;
+    /** Its business events: the context's events route, and the `entity_type` they carry. */
+    history?: {
+        route: string;
+        type: string;
+    };
+    /** Which fields are its description, state, picture… when they are not the conventional
+     *  ones (`summaryOf`). Empty: the convention decides. */
+    summary: SummaryFields;
+    /** The aggregate it is, as a relation of another model names it (`relation: "Cliente"`).
+     *  Without it, the `aggregate` of its model definition, once known. */
+    aggregate?: string;
+    /** Only carries the record type; never read. */
+    readonly _record?: T;
+};
+/** A composer `ResourceRef`, structurally: `core/` does not import the composer. */
+export type EntityRef = {
+    domain: string;
+    kind: string;
+    id?: string;
+    params?: Readonly<Record<string, string>>;
+};
+/**
+ * The params that say what a reference without an id is for: `new` is the form of a record
+ * that does not exist yet, `pick` is the list opened to choose one. Params, because they are
+ * what a composer reference carries and survives a reload with.
+ */
+export declare const NEW_PARAM = "new";
+export declare const PICK_PARAM = "pick";
+/** What was typed where the chooser was asked for: its list opens on that search. */
+export declare const QUERY_PARAM = "q";
+/** The list a record was opened from (its `Trail`): «3 / 64» and the arrows to its neighbours. */
+export declare const TRAIL_PARAM = "from";
+/** A write: its method and its path, `{id}` where the record's key goes. */
+export type WriteRoute = {
+    method: Method;
+    path: string;
+};
+export type EntityRoutes = {
+    list: string;
+    /** With `{id}` where the key goes. Without it, `<list>/<id>` — sincpro_framework's convention. */
+    one?: string;
+    /** `"POST /invoices/{id}/confirm"`, by name. */
+    commands?: Readonly<Record<string, string>>;
+    /** `"POST /invoices"`: where a new record goes. */
+    create?: string;
+    save?: string;
+    preview?: string;
+    draft?: string;
+    history?: {
+        route: string;
+        type: string;
+    };
+    /** `{ image: "logo", state: "estado_pago", person: true }` — not a route, but declared once
+     *  with the rest of what a screen should not have to know. */
+    summary?: SummaryFields;
+    /** `"Cliente"`: what a many2one of another model calls it, so a form resolves it alone. */
+    aggregate?: string;
+};
+/** `"POST /invoices/{id}/confirm"` → its method and path. A write without a method is a bug. */
+export declare function writeRoute(text: string): WriteRoute;
+/** The path with the record's key in place of `{id}`. */
+export declare function pathFor(route: WriteRoute, id?: string): string;
+export declare function entity<T extends AnyRecord = AnyRecord>(key: string, routes: EntityRoutes): Entity<T>;

package/dist/core/entity.js

@@ -0,0 +1,57 @@
+/**
+ * The params that say what a reference without an id is for: `new` is the form of a record
+ * that does not exist yet, `pick` is the list opened to choose one. Params, because they are
+ * what a composer reference carries and survives a reload with.
+ */
+export const NEW_PARAM = "new";
+export const PICK_PARAM = "pick";
+/** What was typed where the chooser was asked for: its list opens on that search. */
+export const QUERY_PARAM = "q";
+/** The list a record was opened from (its `Trail`): «3 / 64» and the arrows to its neighbours. */
+export const TRAIL_PARAM = "from";
+const METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+/** `"POST /invoices/{id}/confirm"` → its method and path. A write without a method is a bug. */
+export function writeRoute(text) {
+    const [method, path] = text.trim().split(/\s+/, 2);
+    if (!METHODS.has(method) || path === undefined)
+        throw new Error(`"${text}" is not "METHOD /path": a write says how it is sent`);
+    return { method: method, path };
+}
+/** The path with the record's key in place of `{id}`. */
+export function pathFor(route, id) {
+    return id === undefined ? route.path : route.path.replace("{id}", encodeURIComponent(id));
+}
+export function entity(key, routes) {
+    if (!/^[^:\s]+:[^:\s]+$/.test(key))
+        throw new Error(`entity key "${key}" is not domain:kind`);
+    const list = routes.list.split("?")[0] ?? routes.list;
+    const template = routes.one ?? `${list}/{id}`;
+    const [domain = "", kind = ""] = key.split(":");
+    return {
+        key,
+        domain,
+        kind,
+        ref: (id) => ({ domain, kind, ...(id === undefined || id === "" ? {} : { id }) }),
+        newRef: () => ({ domain, kind, params: { [NEW_PARAM]: "1" } }),
+        chooserRef: (query) => ({
+            domain,
+            kind,
+            params: {
+                [PICK_PARAM]: "1",
+                ...(query === undefined || query.trim() === ""
+                    ? {}
+                    : { [QUERY_PARAM]: query.trim() }),
+            },
+        }),
+        list: routes.list,
+        one: (id) => template.replace("{id}", encodeURIComponent(id)),
+        commands: Object.fromEntries(Object.entries(routes.commands ?? {}).map(([name, text]) => [name, writeRoute(text)])),
+        ...(routes.create === undefined ? {} : { create: writeRoute(routes.create) }),
+        ...(routes.save === undefined ? {} : { save: writeRoute(routes.save) }),
+        ...(routes.preview === undefined ? {} : { preview: writeRoute(routes.preview) }),
+        ...(routes.draft === undefined ? {} : { draft: writeRoute(routes.draft) }),
+        ...(routes.history === undefined ? {} : { history: routes.history }),
+        summary: routes.summary ?? {},
+        ...(routes.aggregate === undefined ? {} : { aggregate: routes.aggregate }),
+    };
+}

package/dist/core/form.d.ts

@@ -0,0 +1,21 @@
+import type { Meta } from "@sincpro/criteria";
+import { type SummaryFields } from "./summary.js";
+/**
+ * What a record's form shows when the screen names nothing: its fields, and the pages beside
+ * them — read from the model, in the order it declares.
+ *
+ * Context: the default form must be useful on any entity, not a dump of every key. So:
+ *
+ * - the bookkeeping (`version`, `updated_at`) and who made and changed it are not fields: the
+ *   paper says them on its last line (`Record.Audit`); the picture is not a text box;
+ * - a read-only identity is the record's name, not a field to look at;
+ * - a many2one is written by its KEY (`customer_id`, a picker of customers): the expanded
+ *   relation beside it (`customer`) would be the same thing twice;
+ * - a one2many is a page of its own — a list, not a field;
+ * - a value object, and a many2many the backend cannot write yet, are left to the screen.
+ */
+export type FormLayout = {
+    fields: string[];
+    pages: string[];
+};
+export declare function formOf(meta: Meta | null | undefined, summary?: SummaryFields): FormLayout;

package/dist/core/form.js

@@ -0,0 +1,30 @@
+import { BOOKKEEPING } from "./present.js";
+import { summaryFieldsOf } from "./summary.js";
+export function formOf(meta, summary = {}) {
+    if (!meta)
+        return { fields: [], pages: [] };
+    const parts = summaryFieldsOf(meta, {}, summary);
+    const told = new Set([parts.createdAt, parts.createdBy, parts.updatedAt, parts.updatedBy, parts.image].filter((name) => name !== undefined));
+    const keys = new Set(Object.values(meta.fields)
+        .map((field) => (field.kind === "relation" ? field.identified_by : undefined))
+        .filter((name) => typeof name === "string" && name in meta.fields));
+    const fields = [];
+    const pages = [];
+    for (const [name, field] of Object.entries(meta.fields)) {
+        if (BOOKKEEPING.has(name) || told.has(name))
+            continue;
+        if (name === meta.identity && field.readonly)
+            continue;
+        if (field.kind === "embedded")
+            continue;
+        if (field.kind === "relation") {
+            if (field.type === "one2many")
+                pages.push(name);
+            else if (!field.many && !(field.identified_by && keys.has(field.identified_by)))
+                fields.push(name);
+            continue;
+        }
+        fields.push(name);
+    }
+    return { fields, pages };
+}

package/dist/core/history.d.ts

@@ -0,0 +1,20 @@
+import { type AnyRecord, type Meta } from "@sincpro/criteria";
+/**
+ * A record's history as people read it — its business events, newest first.
+ *
+ * Context: sincpro_framework keeps every context's facts in one event table, read over
+ * `GET /<context>-events`, each fact naming the record it is about (`entity_type`,
+ * `entity_id`) and carrying a `label` in every language — the framework's `history_of`.
+ * forge's console read it with a dictionary of field names written by hand; here the words for
+ * the rest of a fact come from the events' own model definition, like any other field.
+ *
+ * These are business facts («Factura confirmada»), never technical logs: those belong to the
+ * observability stack, not to a record's screen.
+ */
+export type HistoryEntry = {
+    id: string;
+    label: string;
+    at: string;
+    detail?: string;
+};
+export declare function historyOf(rows: readonly AnyRecord[], meta: Meta | null | undefined, locale?: string): HistoryEntry[];

package/dist/core/history.js

@@ -0,0 +1,40 @@
+import { labelOf } from "@sincpro/criteria";
+/** What every fact carries: what remains is what this fact says. */
+const ENVELOPE = new Set([
+    "id",
+    "created_at",
+    "updated_at",
+    "version",
+    "label",
+    "entity_type",
+    "entity_id",
+    "entity_version",
+    "correlation_id",
+    "causation_id",
+]);
+function said(value) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    if (Array.isArray(value))
+        return value.length === 0 ? null : value.map(String).join(", ");
+    return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+export function historyOf(rows, meta, locale) {
+    return rows.map((row) => {
+        const label = row["label"];
+        const word = typeof label === "string"
+            ? label
+            : ((locale ? label?.[locale] : undefined) ?? label?.["default"] ?? String(row["id"]));
+        const parts = Object.entries(row)
+            .filter(([key]) => !ENVELOPE.has(key))
+            .map(([key, value]) => [key, said(value)])
+            .filter(([, value]) => value !== null && value !== row["entity_id"])
+            .map(([key, value]) => `${labelOf(meta, key, locale)}: ${value}`);
+        return {
+            id: String(row["id"]),
+            label: word,
+            at: String(row["created_at"] ?? ""),
+            ...(parts.length === 0 ? {} : { detail: parts.join(" · ") }),
+        };
+    });
+}

package/dist/core/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The plain logic: no React, no DOM, no design system — so it is tested in Node, fast, with
+ * no browser. The transport, the entity, the model definition and what a value reads as.
+ * `make doctor` keeps it that way.
+ */
+export { type CachedTransport, cachedTransport, type CacheOptions, } from "./cache.js";
+export { ENGLISH_FRAMEWORK_COPY, type FrameworkCopy, frameworkCopy, installFrameworkCopy, SPANISH_FRAMEWORK_COPY, } from "./copy.js";
+export { changesOf, creationOf, defaultsOf, errorsByField, type FieldState, fieldStateOf, type FieldStates, missingOf, } from "./edit.js";
+export { type Entity, entity, type EntityRef, type EntityRoutes, NEW_PARAM, pathFor, PICK_PARAM, QUERY_PARAM, TRAIL_PARAM, type WriteRoute, writeRoute, } from "./entity.js";
+export { type FormLayout, formOf } from "./form.js";
+export { type HistoryEntry, historyOf } from "./history.js";
+export { defineList, type GroupLevel, isList, type ListDefinition, type ListSpec, type NamedFilter, scopeOf, } from "./list.js";
+export { lookupOf, type LookupOption } from "./lookup.js";
+export { detailOf, measuresOf, sumsOf } from "./measure.js";
+export { type MemoryOptions, type MemoryTable, memoryTransport, } from "./memory.js";
+export { defineMeta, field, type FieldOptions, type MetaSpec, type Words, } from "./meta.js";
+export { type MetaStore, metaStore } from "./metas.js";
+export { BOOKKEEPING, defaultFields, type FieldView, sortKeyOf, textOf, viewOf, } from "./present.js";
+export { type Related, relatedOf } from "./related.js";
+export { entityFor, type RelationField, relationFieldOf, } from "./relation.js";
+export { type RestOptions, restTransport, urlOf } from "./rest.js";
+export { type RetryKeys, retryKeys, unanswered } from "./retry.js";
+export { completeMeta, type JsonSchema, metaFromSchema, type SchemaComponents, } from "./schema.js";
+export { type RecordSummary, type SummaryFields, summaryFieldsOf, summaryOf, type SummaryPart, } from "./summary.js";
+export { placeOf, stepIn, type Trail } from "./trail.js";
+export { type Draft, explain, type Method, type One, type SendOptions, type Transport, TransportError, } from "./transport.js";

package/dist/core/index.js

@@ -0,0 +1,26 @@
+/**
+ * The plain logic: no React, no DOM, no design system — so it is tested in Node, fast, with
+ * no browser. The transport, the entity, the model definition and what a value reads as.
+ * `make doctor` keeps it that way.
+ */
+export { cachedTransport, } from "./cache.js";
+export { ENGLISH_FRAMEWORK_COPY, frameworkCopy, installFrameworkCopy, SPANISH_FRAMEWORK_COPY, } from "./copy.js";
+export { changesOf, creationOf, defaultsOf, errorsByField, fieldStateOf, missingOf, } from "./edit.js";
+export { entity, NEW_PARAM, pathFor, PICK_PARAM, QUERY_PARAM, TRAIL_PARAM, writeRoute, } from "./entity.js";
+export { formOf } from "./form.js";
+export { historyOf } from "./history.js";
+export { defineList, isList, scopeOf, } from "./list.js";
+export { lookupOf } from "./lookup.js";
+export { detailOf, measuresOf, sumsOf } from "./measure.js";
+export { memoryTransport, } from "./memory.js";
+export { defineMeta, field, } from "./meta.js";
+export { metaStore } from "./metas.js";
+export { BOOKKEEPING, defaultFields, sortKeyOf, textOf, viewOf, } from "./present.js";
+export { relatedOf } from "./related.js";
+export { entityFor, relationFieldOf, } from "./relation.js";
+export { restTransport, urlOf } from "./rest.js";
+export { retryKeys, unanswered } from "./retry.js";
+export { completeMeta, metaFromSchema, } from "./schema.js";
+export { summaryFieldsOf, summaryOf, } from "./summary.js";
+export { placeOf, stepIn } from "./trail.js";
+export { explain, TransportError, } from "./transport.js";