@thomasfosterau/pulpit 0.0.0 → 0.1.0

package/dist/edges.d.ts

@@ -0,0 +1,645 @@
+/**
+ * **The edge operations factory** — a relation between nodes as its own
+ * family: a bounded list, a read by id, an idempotent create and a hard
+ * delete, gated by the visibility of the nodes the edge joins.
+ *
+ * The behavioural spec is gardeneria's `apps/api/src/operations/edge-ops.ts`
+ * (`defineEdgeOpsE`), which exists because hand-rolled edge families drift,
+ * and the ninth family's viewer gate or `LIMIT` gets forgotten. Its
+ * hand-rolled owned-child family (`disorders.ts`, the observation → disorder
+ * edge) is the spec for the endpoint gates. A `#NNN` here names a gardeneria
+ * issue.
+ *
+ * ## What an edge is
+ *
+ * An edge is a plain row in its own table: an id, a `createdAt`, one column
+ * per **end** holding the id of the node at that end, and any qualifier
+ * columns of the family's own. It is **not** a node: it has no version chain,
+ * so the chain invariants (`VERSION-CHAIN-001/002`) do not govern it. A delete
+ * is a hard `DELETE`, and there is no update: correcting an edge is deleting
+ * it and asserting the right one. A family declares zero, one or two (or
+ * more) ends; with none, it is a plain bounded row family (gardeneria's
+ * `page_collections`).
+ *
+ * ## The invariants
+ *
+ * - **An edge is readable only if the viewer can read every end**
+ *   (`EDGE-001`). Each end's node is checked against its own leaf's access
+ *   declaration, as that leaf's own `get` and list filter read it (a
+ *   reference leaf's followers arm included, pulpit#92). `get` answers a
+ *   hidden edge as {@link EdgeNotFound} and `list` omits it, never `Forbidden`
+ *   (`SEC-AUTH-ENUM-001`); a related list (the edges at one node) is a `list`
+ *   filtered on that end, so it omits every edge whose other end is hidden.
+ * - **The list filter and the per-edge predicate never disagree.**
+ *   {@link endpointFilter} renders the same facts {@link canViewEndpoint}
+ *   reads, over the ends' joined views; `tests/edges.test.ts` checks every
+ *   endpoint state × viewer.
+ * - **A tombstoned end hides its edges** from every viewer below the
+ *   view-deleted rung. That rung reads a tombstoned end as the leaf's own
+ *   `get` reads the tombstone, by its access rule (pulpit#93), so it can
+ *   list, read and delete an edge whose only hidden end is tombstoned; an
+ *   end hidden for any other reason (a `private` node below the
+ *   view-private rung, say) still hides the edge from it. Nothing is
+ *   deleted: restoring the node (the explicit `restore`,
+ *   `VERSION-CHAIN-006`) brings its edges back as they were.
+ * - **A create names only live nodes the viewer can read.** An end naming a
+ *   missing, hidden or tombstoned node fails `NodeNotFound` (the
+ *   view-deleted rung included), so a create cannot confirm a node exists.
+ * - **Cardinality is declared, and a create past it fails**
+ *   ({@link EdgeCardinalityExceeded}). An end's `maxEdges` bounds how many
+ *   edges may share one node at that end, counting only the edges the
+ *   caller can read whose every end is live (pulpit#77, pulpit#93). A
+ *   hidden edge never counts, so a refusal discloses nothing the caller
+ *   can't read; the cost is a limit that holds only over what each caller
+ *   sees, and a restore that can bring a node past it (see
+ *   {@link EdgeEnd.maxEdges}). A re-assertion of a stored edge resolves
+ *   before the count, so it stays idempotent at a full node.
+ * - **A write discloses no hidden edge's state.** A create runs in the
+ *   order ends → write gate → unique-key collision → cardinality count.
+ *   Under `"fail"` a collision with a hidden edge answers exactly as one
+ *   with a readable edge; under `"ignore"` only a readable, live edge
+ *   resolves, and any other collision is {@link EdgeConflict}. The count
+ *   reads only readable edges (README → `./edges` → What a write
+ *   discloses).
+ * - **Every list is bounded** (`SEC-INPUT-003`): a page is capped at
+ *   `MAX_PAGE_LIMIT`.
+ *
+ * ## The seam
+ *
+ * The edges are read and written through an {@link EdgeStore} the
+ * application supplies (a Drizzle store over the edge table, joining each
+ * end's current-version view; see the package README → Seams). Each end
+ * reads its nodes through an {@link EndpointView}, which a `./subtype`
+ * `LeafStore` already satisfies.
+ *
+ * @copyright Thomas Foster
+ * @module pulpit/edges
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+import * as HashMap from "effect/HashMap";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { type ListFilter } from "./filter.ts";
+import { Forbidden, Unauthorized, type AccessPolicy, type FollowerSeam, type LeafAccess, type LeafRow, type Page, type Viewer, type ViewerAccount } from "./subtype.ts";
+import { NodeNotFound, type ColumnValue } from "./version-chain.ts";
+declare const EdgeNotFound_base: Schema.Class<EdgeNotFound, Schema.TaggedStruct<"EdgeNotFound", {
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
+/**
+ * No edge with this id that the viewer may read: missing, or hidden because
+ * an end is (`SEC-AUTH-ENUM-001`, `EDGE-001`). The wire's 404.
+ *
+ * @since 0.1.0
+ */
+export declare class EdgeNotFound extends EdgeNotFound_base {
+}
+declare const EdgeConflict_base: Schema.Class<EdgeConflict, Schema.TaggedStruct<"EdgeConflict", {
+    readonly type: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
+/**
+ * A create collided with a stored edge on the family's unique key, and the
+ * family's conflict policy does not resolve it: `onConflict: "fail"`, or the
+ * edge it collided with is one the viewer may not read or has a tombstoned
+ * end. The wire's 409. It carries only the family's type, so under `"fail"`
+ * a collision with a hidden edge is the same answer as one with a readable
+ * edge (`SEC-AUTH-ENUM-001`, pulpit#93); under `"ignore"` only a readable,
+ * live edge resolves, and any other collision is this error. It says the
+ * key is taken, never by which edge.
+ *
+ * @since 0.1.0
+ */
+export declare class EdgeConflict extends EdgeConflict_base {
+}
+declare const EdgeCardinalityExceeded_base: Schema.Class<EdgeCardinalityExceeded, Schema.TaggedStruct<"EdgeCardinalityExceeded", {
+    /** The edge family's wire type. */
+    readonly type: Schema.String;
+    /** The end (its alias in the declaration) whose limit was reached. */
+    readonly end: Schema.String;
+    /** The node at that end, which already holds `max` edges the caller can read. */
+    readonly nodeId: Schema.String;
+    /** The declared limit. */
+    readonly max: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
+/**
+ * A create would put more edges at one node than its end's declared
+ * `maxEdges` allows, counting only the edges the caller can read whose every
+ * end is live ({@link EdgeEnd.maxEdges}). The wire's 409.
+ *
+ * @since 0.1.0
+ */
+export declare class EdgeCardinalityExceeded extends EdgeCardinalityExceeded_base {
+}
+declare const EdgeDeclarationError_base: Schema.Class<EdgeDeclarationError, Schema.TaggedStruct<"EdgeDeclarationError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
+/**
+ * An edge family declared against the rules: an end's alias contains a `.`,
+ * or its `maxEdges` is not a positive safe integer. Thrown by
+ * {@link defineEdgeOps} when the family is declared, never an Effect failure,
+ * like `RegistryDeclarationError`: a malformed family must stop its module
+ * loading rather than fail open (a `NaN` limit admits every create) or
+ * refuse every create (a limit of `0`).
+ *
+ * @since 0.1.0
+ */
+export declare class EdgeDeclarationError extends EdgeDeclarationError_base {
+}
+/**
+ * An end's view of its nodes: the endpoint leaf's current-version view
+ * column set and its read by id. A `./subtype` `LeafStore` satisfies it, so
+ * an end usually passes the endpoint leaf's own store.
+ *
+ * @since 0.1.0
+ */
+export interface EndpointView<E, R> {
+    /** The endpoint view's column names; an owned declaration naming a column outside it hides every edge. */
+    readonly columns: ReadonlySet<string>;
+    /** One node of the current-version view by id, or none. Applies no visibility policy. */
+    readonly get: (id: string) => Effect.Effect<Option.Option<LeafRow>, E, R>;
+}
+/**
+ * One end of an edge family: the edge column holding the node id, and how
+ * that node is read and gated.
+ *
+ * @since 0.1.0
+ */
+export interface EdgeEnd<E, R> {
+    /** The edge column holding this end's node id. */
+    readonly column: string;
+    /** The endpoint leaf's wire type: names the `NodeNotFound` a create naming a missing or hidden node fails with. */
+    readonly type: string;
+    /** The endpoint leaf's access declaration, the one its own `defineSubtype` takes. */
+    readonly access: LeafAccess;
+    /** The endpoint leaf's current-version view. */
+    readonly nodes: EndpointView<E, R>;
+    /**
+     * The most edges one node at this end may hold: a positive safe integer,
+     * or {@link defineEdgeOps} throws {@link EdgeDeclarationError}. Absent,
+     * unlimited. A create that would exceed it fails
+     * {@link EdgeCardinalityExceeded}.
+     *
+     * A create counts only the edges at the node that the caller can read
+     * (`EDGE-001`) and whose every end is live (owner decisions on pulpit#77
+     * and pulpit#93), which has three consequences:
+     *
+     * - **No disclosure.** A hidden edge never counts, so a refusal depends
+     *   only on edges the caller can read: it can't tell a node holding hidden
+     *   edges from one holding none.
+     * - **A tombstoned partner frees its slot.** An edge whose other end is
+     *   tombstoned stops counting at once, so retiring a term in a
+     *   single-choice taxonomy doesn't freeze the nodes it classified.
+     * - **The limit is per caller, and can be overshot.** A node may hold
+     *   more than `maxEdges` stored edges: edges a writer can't read don't
+     *   count against that writer, and a `restore` of a tombstoned partner
+     *   brings its edge back without a check (a restore is a chain write and
+     *   reads no edge). An over-limit node keeps its edges; the next create
+     *   at it fails until enough are deleted. Only a caller who can read
+     *   every edge at the node (the view-private rung, typically) is held to
+     *   the limit over all of them.
+     */
+    readonly maxEdges?: number | undefined;
+}
+/**
+ * A family's ends, keyed by alias. The alias is how a list filter names an
+ * end's node columns ({@link endpointColumn}), the name under which the store
+ * joins that end's view, and the `end` an {@link EdgeCardinalityExceeded}
+ * reports. An alias never contains a `.` ({@link defineEdgeOps} throws
+ * {@link EdgeDeclarationError} on one), because `alias.column` must name one
+ * end's column unambiguously.
+ *
+ * @since 0.1.0
+ */
+export type EdgeEnds<E, R> = {
+    readonly [alias: string]: EdgeEnd<E, R>;
+};
+/**
+ * The list-filter column naming `column` of the node at end `alias`:
+ * `alias.column`. {@link endpointFilter} writes these, a family's own list
+ * filter may too, and a store renders each against the view it joined under
+ * that alias.
+ *
+ * @since 0.1.0
+ */
+export declare const endpointColumn: (alias: string, column: string) => string;
+/**
+ * Whether the viewer may read the node at one end (`EDGE-001`): it exists,
+ * it is live or the viewer holds the view-deleted rung (a tombstone is read
+ * as the leaf's own `get` reads it, pulpit#93), and its leaf's access admits
+ * the viewer, a tombstone's included. A reference node is
+ * readable when its view has no `visibility` column, the viewer holds the
+ * view-private rung, it is `public`, or it is `followers` and the viewer is,
+ * or follows, the account its leaf's declared `followersOfColumn` names (the
+ * predicate `defineSubtype`'s `get` runs, pulpit#92); an owned node through
+ * `canViewOwned`'s predicate, where an owner column holding no string reads
+ * as no owner, matching no viewer and never asked of the follower seam. An
+ * owned declaration naming a column the view lacks reads nothing. Never
+ * fails.
+ *
+ * @since 0.1.0
+ */
+export declare const canViewEndpoint: <E, R>(end: EdgeEnd<E, R>, viewer: Viewer, policy: AccessPolicy, followers: FollowerSeam<unknown, R>, node: Option.Option<LeafRow>) => Effect.Effect<boolean, never, R>;
+/**
+ * The list arm of `EDGE-001`: for every end, its node is live (or the viewer
+ * holds the view-deleted rung) and readable by the viewer, over the columns
+ * {@link endpointColumn} names. The same facts as {@link canViewEndpoint},
+ * rendered as a `ListFilter` — the owned arm is `ownedListFilter`, the
+ * reference arm `referencePrivacyFilter`'s, followers arm included
+ * (pulpit#92) — so the two never disagree. A
+ * family with no ends gets `always`.
+ *
+ * @since 0.1.0
+ */
+export declare const endpointFilter: <Following, E, R>(ends: EdgeEnds<E, R>, viewer: Viewer, policy: AccessPolicy, followers: FollowerSeam<Following, unknown>) => ListFilter<Following>;
+/**
+ * What a write gate is asked about: the viewer, the application's role axes,
+ * and the edge being written (a create's column values, or a delete's stored
+ * row).
+ *
+ * @since 0.1.0
+ */
+export interface EdgeWriteRequest {
+    /** The request's viewer. */
+    readonly viewer: Viewer;
+    /** The application's role axes. */
+    readonly policy: AccessPolicy;
+    /** The edge's column values: the create's `values(input)`, or the stored row a delete removes. */
+    readonly edge: EdgeValues;
+}
+/**
+ * The gate `create` and `delete` run after the ends' visibility check. It
+ * fails `Unauthorized` / `Forbidden`, or `NodeNotFound` when it reads an end
+ * (an owned-child gate on a node with no owner), or with the store's `E`.
+ *
+ * @since 0.1.0
+ */
+export type EdgeWriteGate<E, R> = (request: EdgeWriteRequest) => Effect.Effect<unknown, Unauthorized | Forbidden | NodeNotFound | E, R>;
+/**
+ * A gate on one rung of the role axes: anonymous fails `Unauthorized`, a
+ * signed-in viewer below the rung `Forbidden`. `rungGate((policy) =>
+ * policy.canModerate)` is the moderator rung gardeneria's CMS edges take.
+ *
+ * @since 0.1.0
+ */
+export declare const rungGate: (rung: (policy: AccessPolicy) => (account: ViewerAccount) => boolean) => (request: EdgeWriteRequest) => Effect.Effect<ViewerAccount, Unauthorized | Forbidden>;
+/**
+ * The default write gate: the corpus-write rung. Right for an edge joining
+ * reference rows, which is itself reference data.
+ *
+ * @since 0.1.0
+ */
+export declare const corpusWriteGate: (request: EdgeWriteRequest) => Effect.Effect<ViewerAccount, Unauthorized | Forbidden>;
+/**
+ * An edge's column values by name, as a create writes them.
+ *
+ * @since 0.1.0
+ */
+export type EdgeValues = {
+    readonly [column: string]: ColumnValue;
+};
+/**
+ * A stored edge: its id, its creation instant (the list's order), and its columns.
+ *
+ * @since 0.1.0
+ */
+export interface EdgeRow {
+    readonly id: string;
+    readonly createdAt: Date;
+    readonly [column: string]: ColumnValue;
+}
+/**
+ * The persistence seam over one edge table. `E` is the store's own failure,
+ * `R` its requirements (a Drizzle store's `CurrentTransaction`: like the
+ * chain store, it never opens a transaction). Every method applies no policy.
+ *
+ * @since 0.1.0
+ */
+export interface EdgeStore<Row extends EdgeRow, Following, E, R> {
+    /** One edge by id, or none (`LIMIT 1`). */
+    readonly get: (id: string) => Effect.Effect<Option.Option<Row>, E, R>;
+    /**
+     * The page under `where`, with the unpaged total. Each end's
+     * current-version view is INNER JOINed on `view.id = edge.<end column>`
+     * under the end's alias, so `alias.column` names that view's column and a
+     * bare column the edge table's; an edge whose end has no row in its view
+     * is never listed. Ordered by `createdAt`, then `id` (a total order, so a
+     * page cursor cannot skip or repeat a row, #1231). The total is a window
+     * column (`count(*) OVER ()`): exact whenever the page has a row, and `0`
+     * for an empty page, a page past the end included.
+     */
+    readonly list: (query: {
+        readonly where: ListFilter<Following>;
+        readonly limit: number;
+        readonly offset: number;
+    }) => Effect.Effect<Page<Row>, E, R>;
+    /**
+     * How many stored edges hold `nodeId` in `column` and satisfy `where`,
+     * over the same joins as {@link EdgeStore.list} (so `where` reads
+     * `alias.column` exactly as a list's does). The factory passes the
+     * viewer's `EDGE-001` filter and every end's liveness, so only edges the
+     * caller can read with live ends are counted (pulpit#77, pulpit#93).
+     * Called inside the create's transaction, for the cardinality check, once
+     * per bounded end in ascending `nodeId` order. A SQL store locks the node
+     * first (`FOR NO KEY UPDATE`, under READ COMMITTED), so two creates at one
+     * node serialise, and the sorted order means two creates locking the same
+     * pair of nodes cannot deadlock (README → Seams).
+     */
+    readonly countAt: (query: {
+        readonly column: string;
+        readonly nodeId: string;
+        readonly where: ListFilter<Following>;
+    }) => Effect.Effect<number, E, R>;
+    /** The id of the stored edge `values` would collide with on the family's unique key, or none (always none without one). */
+    readonly existing: (values: EdgeValues) => Effect.Effect<Option.Option<string>, E, R>;
+    /** Insert the edge (`ON CONFLICT DO NOTHING RETURNING id`): its new id, or none when the unique key was taken. */
+    readonly insert: (values: EdgeValues) => Effect.Effect<Option.Option<string>, E, R>;
+    /** Hard-delete the edge; whether a row went. */
+    readonly delete: (id: string) => Effect.Effect<boolean, E, R>;
+    /**
+     * Set the edge's validity end column to `to` and update nothing else
+     * (pulpit#210, `EDGE-002`): `UPDATE … SET <column> = $to WHERE id = $id
+     * RETURNING id`; whether a row was updated. Required only by a family that
+     * declares {@link EdgeDefinition.validity}.
+     */
+    readonly closeValidity?: CloseValidity<E, R> | undefined;
+    /**
+     * The node ids at `column` of the stored edges whose `otherColumn` is one
+     * of `ids` and that satisfy `where`, over the same joins as
+     * {@link EdgeStore.list}, as the follower seam's `Following` (pulpit#113):
+     * the subquery `SELECT e.<column> FROM <edge> e JOIN <each end's view> …
+     * WHERE e.<otherColumn> = ANY($ids) AND <where>` in SQL, never a
+     * materialised array, and the set itself in memory. `ids` is never empty
+     * and never longer than `MAX_SET_VALUES`: {@link EdgeOps.memberFilter}
+     * answers `never` (and {@link EdgeOps.nonMemberFilter} `always`) without asking.
+     */
+    readonly members: (query: {
+        readonly column: string;
+        readonly otherColumn: string;
+        readonly ids: ReadonlyArray<string>;
+        readonly where: ListFilter<Following>;
+    }) => Effect.Effect<Following, E, R>;
+    /**
+     * How many stored edges hold each of `ids` in `column` and satisfy
+     * `where`, over the same joins as {@link EdgeStore.list} (pulpit#185): one
+     * `SELECT e.<column>, count(*) FROM <edge> e JOIN <each end's view> …
+     * WHERE e.<column> = ANY($ids) AND <where> GROUP BY e.<column>`, never a
+     * read per id. A node with no such edge has no key. `ids` is never empty,
+     * holds no duplicate and is never longer than `MAX_SET_VALUES`:
+     * {@link EdgeOps.countBy} answers without asking otherwise.
+     */
+    readonly countBy: (query: {
+        readonly column: string;
+        readonly ids: ReadonlyArray<string>;
+        readonly where: ListFilter<Following>;
+    }) => Effect.Effect<HashMap.HashMap<string, number>, E, R>;
+}
+/**
+ * An edge family's declaration: its type and ends, its seams, its create
+ * mapping, conflict policy and write gate, and its row → resource mapper.
+ *
+ * @since 0.1.0
+ */
+export interface EdgeDefinition<Create, Row extends EdgeRow, Resource, Following, E, R> {
+    /** The family's JSON:API wire type: names spans and tags `EdgeNotFound`. */
+    readonly type: string;
+    /** The family's ends by alias; each node must be readable for its edge to be. */
+    readonly ends: EdgeEnds<E, R>;
+    /** The edge table. */
+    readonly edges: EdgeStore<Row, Following, E, R>;
+    /** The request's viewer (effect-auth's session context). */
+    readonly viewer: Effect.Effect<Viewer, never, R>;
+    /** The application's role axes. */
+    readonly policy: AccessPolicy;
+    /** The follower seam the owned ends read; `nobodyFollows` when the runtime provides none. */
+    readonly followers: FollowerSeam<Following, R>;
+    /** The edge's column values from the create input; each end's column must hold its node id. */
+    readonly values: (input: Create) => EdgeValues;
+    /** Shape a stored edge into the resource. */
+    readonly toResource: (row: Row) => Resource;
+    /**
+     * A create colliding with a stored edge on the unique key: `"fail"`
+     * ({@link EdgeConflict}, the default) or `"ignore"` (re-assertion is a
+     * no-op returning the stored edge's id, when the viewer may read it and
+     * its every end is live; otherwise {@link EdgeConflict}).
+     */
+    readonly onConflict?: "fail" | "ignore" | undefined;
+    /** The write gate; {@link corpusWriteGate} when absent. */
+    readonly writeGate?: EdgeWriteGate<E, R> | undefined;
+    /**
+     * The family's validity interval (pulpit#210): the edge columns holding
+     * when it starts and ends to hold (each a `Date`, or `NULL` for open).
+     * With it, a create checks `from ≤ to`, `maxEdges` counts only the edges
+     * valid at the same time as the new one, and `closeValidity` may end an
+     * open interval. Absent, edges have no interval.
+     */
+    readonly validity?: EdgeValidity | undefined;
+}
+/**
+ * {@link EdgeStore.closeValidity}'s shape: set the edge `id`'s `column` to
+ * `to`; whether a row was updated.
+ *
+ * @since 0.1.0
+ */
+export type CloseValidity<E, R> = (id: string, column: string, to: Date) => Effect.Effect<boolean, E, R>;
+/**
+ * An edge family's validity interval columns (pulpit#210). An edge holds
+ * over `[from, to)`: from its `from` instant (or always, when `NULL`) until
+ * its `to` instant (or forever, when `NULL`).
+ *
+ * @since 0.1.0
+ */
+export interface EdgeValidity {
+    readonly from: string;
+    readonly to: string;
+}
+declare const InvalidValidity_base: Schema.Class<InvalidValidity, Schema.TaggedStruct<"InvalidValidity", {
+    readonly type: Schema.String;
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
+/**
+ * An edge's validity interval is malformed: a bound that is neither a
+ * `Date` nor `NULL`, `from` after `to`, or a close that would widen it. The
+ * wire's 422.
+ *
+ * @since 0.1.0
+ */
+export declare class InvalidValidity extends InvalidValidity_base {
+}
+/**
+ * The edges valid at `at` (pulpit#210), as a list filter over a family's
+ * {@link EdgeValidity} columns: `from` is `NULL` or at or before `at`, and
+ * `to` is `NULL` or after it. Pass it as a list's `where`, so "who held
+ * the office on that day" is one gated read.
+ *
+ * @example
+ * ```ts
+ * import { strictEqual } from "node:assert";
+ * import { validAt } from "@thomasfosterau/pulpit/edges";
+ * import { evaluate } from "@thomasfosterau/pulpit/filter";
+ *
+ * const filter = validAt({ from: "validFrom", to: "validTo" }, new Date("2020-06-01"));
+ * const context = { now: new Date(0), contains: () => false };
+ * const row = { validFrom: new Date("2020-01-01"), validTo: null };
+ * strictEqual(evaluate(filter, row, context), true);
+ * strictEqual(evaluate(filter, { ...row, validTo: new Date("2020-03-01") }, context), false);
+ * ```
+ *
+ * @since 0.1.0
+ */
+export declare const validAt: <Following = never>(validity: EdgeValidity, at: Date) => ListFilter<Following>;
+/**
+ * A list request: the bounded page cursor and the family's own predicate.
+ *
+ * @since 0.1.0
+ */
+export interface EdgeListRequest {
+    readonly limit: number;
+    readonly offset: number;
+    /** The family's predicate over edge columns (and {@link endpointColumn}s), or `always`. */
+    readonly where: ListFilter<never>;
+}
+/**
+ * A create's outcome: the edge's id, and whether this call wrote it (`false`
+ * when an `"ignore"` family resolved a re-assertion to the stored edge).
+ *
+ * @since 0.1.0
+ */
+export interface EdgeWrite {
+    readonly id: string;
+    readonly created: boolean;
+}
+/**
+ * The operations {@link defineEdgeOps} produces for one edge family.
+ *
+ * @since 0.1.0
+ */
+export interface EdgeOps<Create, Resource, E, R, Following = never> {
+    /**
+     * One page of the edges the viewer may read, with the unpaged total as the
+     * store reports it (`EDGE-001`: an edge with a hidden or tombstoned end is
+     * omitted). The limit is clamped to `MAX_PAGE_LIMIT` (`SEC-INPUT-003`).
+     * Fails only with the store's `E`.
+     */
+    readonly list: (request: EdgeListRequest) => Effect.Effect<Page<Resource>, E, R>;
+    /**
+     * The edge as a resource. Fails `EdgeNotFound` when it is missing OR an
+     * end is hidden from the viewer (`SEC-AUTH-ENUM-001`, `EDGE-001`).
+     */
+    readonly get: (id: string) => Effect.Effect<Resource, EdgeNotFound | E, R>;
+    /**
+     * Assert the edge. Fails `NodeNotFound` when an end names a node that is
+     * missing, tombstoned or hidden from the viewer (checked before the gate,
+     * so a 403 never confirms a node; a tombstone is `NodeNotFound` to the
+     * view-deleted rung too); the gate's `Unauthorized` / `Forbidden` (or
+     * `NodeNotFound`); `EdgeConflict` on a unique-key collision the conflict
+     * policy does not resolve; `EdgeCardinalityExceeded` when an end's node
+     * already holds its `maxEdges` edges that the caller can read with every
+     * end live. Under `"fail"` a collision with a hidden edge answers exactly
+     * as one with a readable edge; under `"ignore"` only a readable, live edge
+     * resolves (to `{ created: false, id }`), and any other collision is
+     * `EdgeConflict` (`SEC-AUTH-ENUM-001`, pulpit#93). The count reads no
+     * hidden edge ({@link EdgeEnd.maxEdges}). An `EdgeConflict` still says the
+     * key is taken, which only a family whose unique key leaves an end out
+     * can say about a hidden edge (README → `./edges`).
+     */
+    readonly create: (input: Create) => Effect.Effect<EdgeWrite, Unauthorized | Forbidden | NodeNotFound | EdgeConflict | EdgeCardinalityExceeded | InvalidValidity | E, R>;
+    /**
+     * End the edge's validity interval at `at` (pulpit#210): the one update an
+     * edge takes (`EDGE-002`), which sets only the interval's `to` column and
+     * only narrows it: `at` must not be after a closed interval's end, nor
+     * before its start. Fails `EdgeNotFound` for a missing or hidden edge
+     * (before the gate), the gate's failures, and {@link InvalidValidity} for
+     * a family without an interval or an `at` that would widen it.
+     */
+    readonly closeValidity: (id: string, at: Date) => Effect.Effect<{
+        readonly id: string;
+    }, Unauthorized | Forbidden | NodeNotFound | EdgeNotFound | InvalidValidity | E, R>;
+    /**
+     * Hard-delete the edge. Fails `EdgeNotFound` when it is missing or hidden
+     * from the viewer (checked before the gate; the view-deleted rung reads an
+     * edge whose only hidden end is tombstoned, so it can delete one), then
+     * the gate's failures.
+     */
+    readonly delete: (id: string) => Effect.Effect<{
+        readonly id: string;
+    }, Unauthorized | Forbidden | NodeNotFound | EdgeNotFound | E, R>;
+    /**
+     * Edge membership as a list filter for the leaf at `end` (pulpit#113):
+     * `id IN (<the end's node ids of the edges whose other end is one of
+     * otherIds>)`, so `?categories=1,2` lists the posts holding a
+     * `post_category` edge to one of those terms. Only edges the viewer can
+     * read count (`EDGE-001`, the same `endpointFilter` as {@link list}): an
+     * edge with a hidden end, or a tombstoned end below the view-deleted
+     * rung, never makes a row a member, so a hidden term's edges are never
+     * confirmed. The filter is the store's `members` subquery under
+     * `./filter`'s `in` node, so a `NULL` id is never a member.
+     *
+     * `end` names the member end by alias, and the family's one other end is
+     * the end `otherIds` name. Fails closed, as `never`, without reading the
+     * store: no `otherIds`, more than `MAX_SET_VALUES` of them
+     * (`SEC-INPUT-003`), an `end` the family doesn't declare, or a family
+     * without exactly two ends. Fails only with the store's `E`.
+     */
+    readonly memberFilter: (end: string, otherIds: ReadonlyArray<string>) => Effect.Effect<ListFilter<Following>, E, R>;
+    /**
+     * Edge non-membership as a list filter for the leaf at `end` (pulpit#191):
+     * the complement of {@link EdgeOps.memberFilter} over the same store
+     * `members` subquery, `(id IS NULL OR id NOT IN (…))` under `./filter`'s
+     * `notIn` node, so `?categories_exclude=1,2` lists the posts holding no
+     * readable `post_category` edge to those terms. The member set and this
+     * filter partition the rows a leaf's `list` reads.
+     *
+     * Only edges the viewer can read count as a membership (`EDGE-001`): a row
+     * whose only edge to `otherIds` is hidden from the viewer, or has a
+     * tombstoned end below the view-deleted rung, is not excluded, so the
+     * hidden edge is never confirmed. An exclusion fails closed by excluding
+     * nothing: no `otherIds`, more than `MAX_SET_VALUES` of them
+     * (`SEC-INPUT-003`; an adapter caps its list before this), an `end` the
+     * family doesn't declare, or a family without exactly two ends all give
+     * `always` without reading the store. Fails only with the store's `E`.
+     */
+    readonly nonMemberFilter: (end: string, otherIds: ReadonlyArray<string>) => Effect.Effect<ListFilter<Following>, E, R>;
+    /**
+     * The number of edges the viewer can read at each node of `ids` at end
+     * `end` (pulpit#185), in one grouped store read: a taxonomy term's post
+     * count, for every term on a page. Only edges {@link list} would show
+     * count (`EDGE-001`, the same `endpointFilter`, and `where`, the family's
+     * own predicate, as {@link EdgeListRequest.where}): an edge with a hidden
+     * end, or a tombstoned end below the view-deleted rung, never counts, so a
+     * hidden or tombstoned node at `end` counts `0` and its edges are never
+     * confirmed.
+     *
+     * Every requested id (deduplicated) has a key, `0` for a node with no
+     * readable edge. Fails closed, every count `0` without reading the store,
+     * for more than `MAX_SET_VALUES` ids (`SEC-INPUT-003`) or an `end` the
+     * family doesn't declare; no ids read nothing. Fails only with the
+     * store's `E`.
+     */
+    readonly countBy: (end: string, ids: ReadonlyArray<string>, where?: ListFilter<never> | undefined) => Effect.Effect<HashMap.HashMap<string, number>, E, R>;
+}
+/**
+ * Bind an edge family's operations. Every produced operation is traced as
+ * `${type}.<operation>`; the writes run in the caller's transaction (the
+ * boundary is the caller's, website #1883), and a create's cardinality
+ * count and insert share it (README → Seams).
+ *
+ * Throws {@link EdgeDeclarationError}, when the family is declared, for an
+ * end alias containing a `.` or a `maxEdges` that is not a positive safe
+ * integer.
+ *
+ * @since 0.1.0
+ */
+export declare const defineEdgeOps: <Create, Row extends EdgeRow, Resource, Following, E, R>(definition: EdgeDefinition<Create, Row, Resource, Following, E, R>) => EdgeOps<Create, Resource, E, R, Following>;
+export {};
+//# sourceMappingURL=edges.d.ts.map

package/dist/edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edges.d.ts","sourceRoot":"","sources":["../src/edges.ts"],"names":[],"mappings":"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"}