@dtmd/temper 0.0.4 → 0.0.7

package/dist/src/generated/Declarations.d.ts

@@ -0,0 +1,89 @@
+import type { AssemblyFactRow } from "./AssemblyFactRow.js";
+import type { ClauseRow } from "./ClauseRow.js";
+import type { IncludeRow } from "./IncludeRow.js";
+import type { KindFactRow } from "./KindFactRow.js";
+import type { MentionRow } from "./MentionRow.js";
+import type { NestedMemberRow } from "./NestedMemberRow.js";
+import type { RegistrationRow } from "./RegistrationRow.js";
+import type { RequirementRow } from "./RequirementRow.js";
+import type { SatisfiesRow } from "./SatisfiesRow.js";
+import type { SettingsRow } from "./SettingsRow.js";
+/**
+ * The lock's **declaration-row family** — the composed program's erased declarations,
+ * beside the
+ * per-member provenance and emit-fingerprint rows. Seven sub-families: the program's
+ * [kind facts](KindFactRow), its [clauses](ClauseRow), its [requirements](RequirementRow),
+ * its assembly facts, its
+ * [`satisfies`](SatisfiesRow) fill edges, its [`mention`](MentionRow) edges, and its
+ * [`nested_member`](NestedMemberRow) rows.
+ *
+ * Written into the lock by [`emit`] off the SDK's own payload ([`Declarations::write_into`])
+ * and read back here ([`read_declarations`]) for the gate's one disk-vs-lock comparison —
+ * `import`'s own extraction still writes this family for the `check` path it feeds
+ * (`GATE-READ-LOCK-DEMOLITION`, next in the chain, moves that read onto the lock too).
+ * Each family's columns are owned scalars (or small owned collections for a set-scope
+ * facet) so the read and write sides are the same shape: the lock is the vocabulary,
+ * not a typed IR. `#[derive(Deserialize)]` doubles this shape as the SDK payload's own
+ * wire format — the same rows, whether they arrive off disk or off the seam's JSON pipe.
+ *
+ * Not `Eq`: its [`ClauseRow`]s may carry `f64` `range` bounds.
+ */
+export type Declarations = {
+    /**
+     * The kind facts — one per kind in the program.
+     */
+    kinds: Array<KindFactRow>;
+    /**
+     * The clauses of every kind's effective contract.
+     */
+    clauses: Array<ClauseRow>;
+    /**
+     * The named requirements the assembly declares.
+     */
+    requirements: Array<RequirementRow>;
+    /**
+     * The assembly-scope facts — the root member's declared enforcement `mode`,
+     * edges.
+     */
+    assembly: Array<AssemblyFactRow>;
+    /**
+     * The member→requirement fill edges — every imported member's `satisfies` keys,
+     * so the roster/coverage
+     * tiers ride the lock rather than re-importing the harness.
+     */
+    satisfies: Array<SatisfiesRow>;
+    /**
+     * The authored `n` mention edges — every member's already-resolved prose
+     * mentions, so the reference graph carries them alongside every other declared
+     * edge locus.
+     */
+    mentions: Array<MentionRow>;
+    /**
+     * The composed-prose includes — a seam-inbound family only: `emit` resolves each
+     * against disk, splices the target's bytes into the host's projection, and lowers
+     * it to a fingerprinted `include` source dependency (never written back into this
+     * declaration table, so a lock round-trip reads it empty).
+     */
+    includes: Array<IncludeRow>;
+    /**
+     * The host members' declared embedded-member facts — captured as declaration
+     * rows rather than a second copy the engine reads back off the rendered fence
+     * (0018, "the projection is not the database").
+     */
+    nested_members: Array<NestedMemberRow>;
+    /**
+     * The fields-only registration members the SDK erased for the manifest write face —
+     * seam-inbound carrying their folded fields, so `emit` routes each host manifest whole
+     * through the canonical write face. The lock's `registration` family records only each
+     * member's identity and collection address; the fields live in the projected manifest
+     * artifact, never a second copy read back (0018), so a lock round-trip reads them
+     * fieldless.
+     */
+    registrations: Array<RegistrationRow>;
+    /**
+     * The harness-level settings residue — seam-inbound opaque `settings.json` keys with
+     * no member home, folded into their manifest's residue at emit. Like `includes`, never
+     * written into this declaration table, so a lock round-trip reads none.
+     */
+    settings: Array<SettingsRow>;
+};

package/dist/src/generated/Declarations.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/DegreeBoundRow.d.ts

@@ -0,0 +1,15 @@
+import type { EdgeBoundRow } from "./EdgeBoundRow.js";
+/**
+ * A requirement row's `degree` bound — the in/out edge-count bound every satisfier
+ * must land in.
+ */
+export type DegreeBoundRow = {
+    /**
+     * The bound on a satisfier's incoming edge count, when constrained.
+     */
+    incoming?: EdgeBoundRow;
+    /**
+     * The bound on a satisfier's outgoing edge count, when constrained.
+     */
+    outgoing?: EdgeBoundRow;
+};

package/dist/src/generated/DegreeBoundRow.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/EdgeBoundRow.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One direction's inclusive `[min, max]` edge-count bound, each endpoint optional.
+ */
+export type EdgeBoundRow = {
+    /**
+     * The inclusive lower bound. `None` ⇒ no lower bound.
+     */
+    min?: number;
+    /**
+     * The inclusive upper bound. `None` ⇒ unbounded above.
+     */
+    max?: number;
+};

package/dist/src/generated/EdgeBoundRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/src/generated/EmbeddedMember.d.ts

@@ -0,0 +1,45 @@
+import type { EmbeddedMemberCollectionEntry } from "./EmbeddedMemberCollectionEntry.js";
+/**
+ * A **nested member** folded from its parent's body at the **embedded locus**,
+ * extracted from a member fence
+ * at the floor. It carries the child kind it instantiates (`decision`) and the fence
+ * key that names this instance among its embedded siblings (`surface-authority`),
+ * plus its own **prose leaves** — top-level authored strings — and its own **nested
+ * members**, one layer deeper: a collection's entries, each itself an
+ * [`EmbeddedMember`] (`rejected.baked-projection`), in authored order. Every leaf is
+ * addressed structurally (member + kind + key + child path) so drift, `impact`, and
+ * citations survive rewording ([`EmbeddedMember::addressed_leaves`]).
+ *
+ * Floor leaves carry no mentions — interpolation stays deferred until a floor
+ * mention syntax is separately ratified — so a
+ * leaf is a plain [`String`], not a mention-bearing span.
+ */
+export type EmbeddedMember = {
+    /**
+     * The child kind this member instantiates — the fence info string's
+     * `member.<kind>` (`decision`), one of the host kind's declared templates.
+     */
+    kind: string;
+    /**
+     * The fence key naming this instance among its embedded siblings in the same
+     * host member — the info string's second token (`surface-authority`). Part of a
+     * leaf's address, so it is keyed, never positional.
+     */
+    key: string;
+    /**
+     * This member's own top-level **prose leaves** — field name → authored string,
+     * in stable (sorted) key order so serialization is deterministic.
+     */
+    leaves: {
+        [key in string]: string;
+    };
+    /**
+     * This member's own **nested members**, one layer deeper — one entry per
+     * collection member, in authored order, so a collection leaf addresses as
+     * `<collection>.<entry>.<field>` (`rejected.baked-projection.because`). Each
+     * entry's collection name and key are keyed identity, never positional — an
+     * address that survives insertion and reorder even though the list itself is
+     * ordered.
+     */
+    members: Array<EmbeddedMemberCollectionEntry>;
+};

package/dist/src/generated/EmbeddedMember.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/EmbeddedMemberCollectionEntry.d.ts

@@ -0,0 +1,21 @@
+import type { EmbeddedMember } from "./EmbeddedMember.js";
+/**
+ * One entry in an [`EmbeddedMember`]'s sibling collection: the collection name it
+ * belongs to, its own key among that collection's siblings, and its own nested
+ * member — the same identity a [`CollectionEntryRow`](crate::drift::CollectionEntryRow)
+ * carries, expanded one layer.
+ */
+export type EmbeddedMemberCollectionEntry = {
+    /**
+     * The collection this entry belongs to.
+     */
+    collection: string;
+    /**
+     * The entry's key among its collection's siblings.
+     */
+    key: string;
+    /**
+     * The entry's own nested member.
+     */
+    member: EmbeddedMember;
+};

package/dist/src/generated/EmbeddedMemberCollectionEntry.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/FeatureValue.d.ts

@@ -0,0 +1,23 @@
+import type { ValueType } from "./ValueType.js";
+/**
+ * One extracted feature value: a scalar field (carrying its parsed source
+ * [`ValueType`] alongside its comparison text), a list field (e.g. a YAML sequence
+ * like `allowed-tools`), or a map field. Scalar predicates (`min_len`, `enum`,
+ * `deny`, `allowed_chars`) read the scalar text; presence predicates
+ * (`required`, `forbidden_keys`) need only the key; the `type` primitive
+ * (forthcoming) reads [`FeatureValue::kind`].
+ */
+export type FeatureValue = {
+    "Scalar": {
+        /**
+         * The parsed source kind of the scalar.
+         */
+        kind: ValueType;
+        /**
+         * The scalar as text (the YAML/JSON scalar stringified).
+         */
+        text: string;
+    };
+} | {
+    "List": Array<string>;
+} | "Map";

package/dist/src/generated/FeatureValue.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/Features.d.ts

@@ -0,0 +1,82 @@
+import type { EmbeddedMember } from "./EmbeddedMember.js";
+import type { FeatureValue } from "./FeatureValue.js";
+import type { FencedBlock } from "./FencedBlock.js";
+import type { Section } from "./Section.js";
+/**
+ * An artifact's deterministically-extracted features, keyed for generic clause
+ * lookup. Everything here is surface-decidable; nothing is inferred meaning.
+ */
+export type Features = {
+    /**
+     * The artifact id used in diagnostics (for a skill, its `name`).
+     */
+    id: string;
+    /**
+     * Frontmatter fields by name — the typed fields *and* the `extra` keys, so
+     * a clause resolves `name`/`description`/`version` or any unknown key
+     * (e.g. for `forbidden_keys`) through one generic lookup.
+     */
+    fields: {
+        [key in string]: FeatureValue;
+    };
+    /**
+     * The artifact body's line count (for `max_lines`).
+     */
+    body_lines: number;
+    /**
+     * The ATX headings (`#`..`######`) in the body, in document order, with the
+     * `#` run and any closing `#` run trimmed (for `require_sections`). A `#`
+     * inside a fenced code block is not a heading.
+     */
+    headings: Array<string>;
+    /**
+     * The body's ATX [`Section`]s (heading + the body span beneath it), in
+     * document order — the feature a `section_contains` clause decides over.
+     * A
+     * superset of [`headings`](Features::headings): where `headings` carries only
+     * each heading's text, a section pairs it with its body span so a marker check
+     * has prose to search.
+     */
+    sections: Array<Section>;
+    /**
+     * The name of the directory the unit was imported from, off provenance
+     * (for `name-matches-dir`). `None` when the source path has no parent.
+     */
+    source_dir: string | null;
+    /**
+     * The body's format-executed directive occurrences, in document order — the
+     * `at-import` `@path` targets a `directives` primitive extracts.
+     * A body-derived feature like [`headings`](Features::headings)/[`sections`](Features::sections):
+     * the raw occurrence strings only, resolution/classing a later slice. Empty
+     * when the kind composes no `directives` primitive.
+     */
+    directives: Array<string>;
+    /**
+     * The body's fenced code blocks, in document order — each block's info string
+     * paired with its interior content, the feature a `fenced` primitive yields.
+     * A body-derived feature like
+     * [`headings`](Features::headings)/[`sections`](Features::sections)/[`directives`](Features::directives):
+     * the same fence boundaries the heading extractor tracks, surfaced whole. Empty
+     * when the kind composes no `fenced` primitive.
+     */
+    fenced_blocks: Array<FencedBlock>;
+    /**
+     * The host member's own **nested members** — its declared [`EmbeddedMember`]s,
+     * read off the lock's own `Declarations::nested_members` rows by this member's
+     * `kind:name` address ([`nested_members_from_rows`]), never mined from
+     * [`fenced_blocks`](Features::fenced_blocks) (0018, "the projection is not the
+     * database"). Empty when the lock carries no row for this member.
+     */
+    nested_members: Array<EmbeddedMember>;
+    /**
+     * The requirements this artifact opts into filling — the authored
+     * `[representation].satisfies` bindings, surfaced for the coverage check.
+     * This is a *representation* edge
+     * the coverage resolver reads, NOT
+     * a contract-checkable frontmatter field — so it lives here, distinct from
+     * `fields`, and never resolves through [`Features::field`]. The authored
+     * `rationale` is deliberately absent: it is the human *why*, never a
+     * decidable feature.
+     */
+    satisfies: Array<string>;
+};

package/dist/src/generated/Features.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/FencedBlock.d.ts

@@ -0,0 +1,24 @@
+/**
+ * One fenced code block of a markdown body: its **info string** (the text after
+ * the opening fence — `sh`, `toml`, `toml member.foo` — trimmed) paired with the
+ * block's **interior content** (the lines between the fences, rejoined with `\n`).
+ * The feature a `fenced` primitive yields: fenced extraction
+ * composed with a TOML parse yields an embedded member's features, declared data
+ * at body position. Surface-decidable like every other feature — the fence
+ * boundaries are the ones [`body_headings`] already tracks, so a block is never a
+ * guess. The info string is available so the embedded-member consumer can key on
+ * `member.<name>`; this generic primitive yields the raw blocks only, the TOML
+ * composition a later slice.
+ */
+export type FencedBlock = {
+    /**
+     * The opening fence's info string, trimmed — `sh`, `toml`, or empty for a bare
+     * fence. The declared kind the embedded-member consumer keys on.
+     */
+    info: string;
+    /**
+     * The block's interior content — the lines between the fences, rejoined with
+     * `\n`, byte-faithful to the body span exactly as a [`Section`]'s body is.
+     */
+    content: string;
+};

package/dist/src/generated/FencedBlock.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/src/generated/IncludeRow.d.ts

@@ -0,0 +1,18 @@
+/**
+ * One composed-prose include the SDK declares — the host member's own `kind:name`
+ * address and the include target's path, resolved by the SDK against the stating
+ * module (never the workspace) to an absolute path. A seam-inbound row only: `emit`
+ * resolves it against disk ([`resolve_source_dependency`]), splices the target's bytes
+ * into the host projection at the body's include slot, and lowers it to a fingerprinted
+ * `include` source dependency — this row itself never reaches the lock.
+ */
+export type IncludeRow = {
+    /**
+     * The host member's own `kind:name` address.
+     */
+    member: string;
+    /**
+     * The include target's SDK-resolved absolute path.
+     */
+    source_path: string;
+};

package/dist/src/generated/IncludeRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/src/generated/KindFactRow.d.ts

@@ -0,0 +1,65 @@
+import type { CollectionAddressRow } from "./CollectionAddressRow.js";
+import type { LayoutRow } from "./LayoutRow.js";
+/**
+ * One kind's declaration row — its identity and declared runtime facts.
+ * The optional facts are omitted from the lock when the kind declares none, so the row
+ * round-trips to exactly what was written.
+ */
+export type KindFactRow = {
+    /**
+     * The bare kind name.
+     */
+    name: string;
+    /**
+     * The declared provider authority, when the kind qualifies by one.
+     */
+    provider?: string;
+    /**
+     * The `governs` locus root directory.
+     */
+    governs_root: string;
+    /**
+     * The `governs` locus filename glob.
+     */
+    governs_glob: string;
+    /**
+     * The declared projection format label, when declared.
+     */
+    format?: string;
+    /**
+     * The declared unit-shape label, when declared.
+     */
+    unit_shape?: string;
+    /**
+     * The declared registration channel set's wire labels, in declaration order.
+     * Empty for a kind that declares none, the same tolerant round-trip
+     * [`templates`](KindFactRow::templates) takes.
+     */
+    registration?: Array<string>;
+    /**
+     * The host kind's declared nesting templates — the embedded child kind names it
+     * folds embedded members of. Empty for
+     * a kind that nests nothing, the tolerant round-trip a lockless/template-less
+     * kind takes.
+     */
+    templates?: Array<string>;
+    /**
+     * The declared content: absent for a `file`-content kind (the default the whole
+     * built-in set takes, so those rows stay byte-identical), a [`LayoutRow`] for a
+     * kind whose body is a declared layout over its heading tree.
+     */
+    content?: LayoutRow;
+    /**
+     * The **fields-only** body-shape marker — `fields` for a no-body-slot kind (a hook,
+     * an MCP server); absent for a body-bearing kind, whose body is `file` or a `content`
+     * layout. The tolerant `#[serde(default)]` round-trip the rest of the optional facts
+     * take, so a body-bearing kind's row stays byte-identical.
+     */
+    shape?: string;
+    /**
+     * The declared **collection address** — for a registration member surfacing inside a
+     * host manifest, which manifest and which key path it keys at. Absent for a
+     * file-locus kind, so an ordinary row stays byte-identical.
+     */
+    collection_address?: CollectionAddressRow;
+};

package/dist/src/generated/KindFactRow.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/LayoutRegionRow.d.ts

@@ -0,0 +1,29 @@
+/**
+ * One [`LayoutRow`] region — one of the three corpus primitives, flattened to a
+ * discriminator plus each primitive's own optional columns (the same discriminator +
+ * optional-columns shape [`AssemblyFactRow`] takes). `prose` carries an optional
+ * `import`; `field` a `slot`; `collection` a `member_kind` and an optional `key`.
+ */
+export type LayoutRegionRow = {
+    /**
+     * The primitive discriminator: `prose`, `field`, or `collection`.
+     */
+    region: string;
+    /**
+     * A `prose` region's import reference, when it imports a file's contents rather
+     * than carrying its own verbatim words.
+     */
+    import?: string;
+    /**
+     * A `field` region's named field slot.
+     */
+    slot?: string;
+    /**
+     * A `collection` region's child member kind.
+     */
+    member_kind?: string;
+    /**
+     * A `collection` region's explicit identity key, when declared.
+     */
+    key?: string;
+};

package/dist/src/generated/LayoutRegionRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/src/generated/LayoutRow.d.ts

@@ -0,0 +1,12 @@
+import type { LayoutRegionRow } from "./LayoutRegionRow.js";
+/**
+ * A kind's declared **layout** — the ordered region rows a `layout`-content kind's body
+ * is read as. Absent from a [`KindFactRow`] means the kind is `file`-content; a present
+ * (even empty) layout means the body is a declared template.
+ */
+export type LayoutRow = {
+    /**
+     * The layout's regions, in declared document order.
+     */
+    regions: Array<LayoutRegionRow>;
+};

package/dist/src/generated/LayoutRow.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/MentionRow.d.ts

@@ -0,0 +1,17 @@
+/**
+ * One authored `n` mention edge's declaration row — the citing member's own
+ * `kind:name` address and the address its mention names (another member's
+ * `kind:name`, or a bare requirement name), already resolved at emit. Recorded
+ * unconditionally: a dangling mention never reaches the lock (`emit` refuses
+ * first), so this row carries no resolution state of its own.
+ */
+export type MentionRow = {
+    /**
+     * The citing member's own `kind:name` address.
+     */
+    member: string;
+    /**
+     * The address the mention names.
+     */
+    target: string;
+};

package/dist/src/generated/MentionRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/src/generated/NestedMemberRow.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionEntryWire } from "./CollectionEntryWire.js";
+/**
+ * One host member's declared embedded-member value's declaration row — its
+ * identity (the host's own `kind:name` address, the embedded child kind, and its
+ * key) plus its leaves and sibling collections: the same composed value
+ * `blocks()` renders into the host's `member.<kind> <key>` fence. The sole fact
+ * source the read side consumes (`crate::builtin_kind::features`, matched by
+ * `host` address) — never a second copy of a value the engine reads back off its
+ * own rendering (0018, "the projection is not the database").
+ */
+export type NestedMemberRow = {
+    /**
+     * The host member's own `kind:name` address.
+     */
+    host: string;
+    /**
+     * The embedded child kind this value instantiates.
+     */
+    kind: string;
+    /**
+     * The value's key — the identity a leaf address carries.
+     */
+    key: string;
+    /**
+     * Prose leaves, keyed by field name.
+     */
+    leaves: {
+        [key in string]: string;
+    };
+    /**
+     * Sibling collections, one row per entry, in authored order — the SDK's
+     * collection-name-keyed wire shape flattened by [`deserialize_collections`].
+     * The Rust side flattens the map to a `Vec`; the seam type carries the wire
+     * shape the flatten reads, a map of collection name to its ordered entries.
+     */
+    collections: {
+        [key in string]: Array<CollectionEntryWire>;
+    };
+};

package/dist/src/generated/NestedMemberRow.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/Payload.d.ts

@@ -0,0 +1,25 @@
+import type { Declarations } from "./Declarations.js";
+import type { PayloadMember } from "./PayloadMember.js";
+/**
+ * The whole seam payload the SDK program prints to stdout:
+ * the
+ * declaration rows (the lock's seven families) and every projected member's erased
+ * payload. The engine is the sole compiler of every projection and the whole lock
+ * from this one value — no harness re-supply, the payload IS the source.
+ *
+ * Not `Eq`: its declarations may carry `f64` `range` bounds ([`RangeBoundRow`]).
+ */
+export type Payload = {
+    /**
+     * The pinned seam version this payload was compiled against.
+     */
+    version: number;
+    /**
+     * The seven declaration families.
+     */
+    declarations: Declarations;
+    /**
+     * Every projected member.
+     */
+    members: Array<PayloadMember>;
+};

package/dist/src/generated/Payload.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generated/PayloadMember.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One projected member's erased payload — the SDK's whole output surface for a
+ * member that lives at a path locus (`sdk/src/generated/PayloadMember`). An
+ * embedded member never appears here (it carries no standalone projection); its
+ * facts ride the [`NestedMemberRow`] family instead.
+ */
+export type PayloadMember = {
+    /**
+     * The kind's bare name — joins this payload's own `declarations.kinds` family.
+     */
+    kind: string;
+    /**
+     * Identity within the kind.
+     */
+    name: string;
+    /**
+     * The kind's typed fields, flat and ordered — the projected frontmatter. The
+     * value is arbitrary JSON, so the seam type is `unknown`, never a serde_json
+     * binding — the SDK reads the field values, never the engine over this pipe.
+     */
+    fields: Array<[string, unknown]>;
+    /**
+     * The resolved prose body, byte-faithful.
+     */
+    body: string;
+    /**
+     * The resolved `file()` asset's absolute path, when the member's prose is
+     * `file()` — absent for `text`/`blocks` prose or no prose.
+     */
+    source_path?: string;
+};

package/dist/src/generated/PayloadMember.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/src/generated/RangeBoundRow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A `range` clause row's inclusive numeric bound — `f64` so one predicate spans both
+ * integer and fractional fields. Not `Eq`: `f64` is only `PartialEq`, which is why
+ * the whole clause-row family it rides is `PartialEq`-only.
+ */
+export type RangeBoundRow = {
+    /**
+     * The inclusive lower bound.
+     */
+    min: number;
+    /**
+     * The inclusive upper bound.
+     */
+    max: number;
+};

package/dist/src/generated/RangeBoundRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};