@loradb/lora-graphql 0.16.2

package/dist/driver.d.ts

@@ -0,0 +1,117 @@
+export type LoraParams = Record<string, unknown>;
+export interface Statement {
+    text: string;
+    params: LoraParams;
+}
+export interface QueryResult {
+    columns: string[];
+    rows: Array<Record<string, unknown>>;
+}
+export interface PlanNode {
+    id: number;
+    operator: string;
+    details: Record<string, string>;
+    estimatedRows: number | null;
+    children: PlanNode[];
+}
+export interface QueryPlan {
+    query: string;
+    shape: "readOnly" | "mutating";
+    resultColumns: string[];
+    tree: PlanNode;
+}
+export interface RunOptions {
+    /** `read` runs in a read-only transaction: the engine rejects writes. */
+    mode: "read" | "write";
+    timeoutMs?: number | undefined;
+    signal?: AbortSignal | undefined;
+    /**
+     * A read the library vouches for: generated, or a @cypher statement
+     * checked read-only at startup. The driver may stream it outside a
+     * read-only transaction.
+     */
+    verified?: boolean;
+}
+/** An open interactive transaction: statements see earlier writes. */
+export interface DriverTransaction {
+    execute(statement: Statement): Promise<QueryResult>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    /** False once committed, rolled back, or failed (a failure rolls back). */
+    readonly isOpen: boolean;
+}
+export interface LoraDriver {
+    /** Run statements atomically, in one transaction, in order. */
+    run(statements: Statement[], options: RunOptions): Promise<QueryResult[]>;
+    /**
+     * Open an interactive transaction. Needed for mutations, which check
+     * their writes (connect targets, cardinality, authorization) before
+     * committing. Optional: the WASM binding has none, so it serves reads.
+     */
+    begin?(options: RunOptions): Promise<DriverTransaction>;
+    /** Plan a statement without running it. Optional: the WASM binding has no `explain()`. */
+    explain?(statement: Statement): Promise<QueryPlan>;
+    /** The engine's committed change feed (lora-node `db.changes()`). */
+    changes?(options: {
+        fromLsn?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<DriverChangeBatch> & {
+        ready: Promise<void>;
+    };
+}
+/** One change of a committed write, as lora-node reports it. */
+export interface DriverChange {
+    kind: "nodeCreated" | "nodeUpdated" | "nodeDeleted" | "relationshipCreated" | "relationshipUpdated" | "relationshipDeleted" | "reset";
+    id?: number;
+    labels?: string[];
+    type?: string;
+    startId?: number;
+    endId?: number;
+    properties?: Record<string, unknown>;
+}
+export interface DriverChangeBatch {
+    lsn: number;
+    changes: DriverChange[];
+}
+/** The subset of a LoraDB `Database` the adapter calls. */
+export interface LoraDatabaseLike {
+    transaction(statements: Array<{
+        query: string;
+        params?: never;
+    }>, mode?: "read_write" | "read_only", options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<QueryResult[]>;
+    explain?(query: string, params?: never): Promise<QueryPlan>;
+    changes?(options?: {
+        fromLsn?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<DriverChangeBatch> & {
+        ready: Promise<void>;
+    };
+    stream?(query: string, params?: never, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): {
+        columns(): string[];
+        toArray(): Promise<Array<Record<string, unknown>>>;
+    };
+    begin?(mode?: "read_write" | "read_only"): Promise<{
+        execute(query: string, params?: never, options?: {
+            timeoutMs?: number;
+            signal?: AbortSignal;
+        }): Promise<QueryResult>;
+        commit(): Promise<void>;
+        rollback(): Promise<void>;
+        readonly isOpen: boolean;
+    }>;
+}
+/**
+ * Wrap a `Database` from `@loradb/lora-node` or `@loradb/lora-wasm`.
+ *
+ * ```ts
+ * const db = await createDatabase();
+ * const lora = new LoraGraphQL({ typeDefs, driver: loraDriver(db) });
+ * ```
+ */
+export declare function loraDriver(db: LoraDatabaseLike): LoraDriver;

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+import { GraphQLError } from 'graphql';
+export interface ModelProblem {
+    /** Type the problem is in, when it belongs to one. */
+    type?: string;
+    /** Field the problem is in, when it belongs to one. */
+    field?: string;
+    message: string;
+}
+/**
+ * The annotated SDL is invalid. Carries every problem found, not just the
+ * first, each located by type and field.
+ */
+export declare class ModelError extends Error {
+    readonly problems: readonly ModelProblem[];
+    constructor(problems: ModelProblem[]);
+}
+export declare function formatProblem(p: ModelProblem): string;
+export type LoraGraphQLErrorCode = "BAD_USER_INPUT" | "INVALID_CURSOR" | "LIMIT_EXCEEDED" | "COST_EXCEEDED" | "UNAUTHENTICATED" | "FORBIDDEN" | "NOT_FOUND" | "CONSTRAINT_VIOLATION" | "DATABASE_ERROR";
+/** A request-time error with a stable `extensions.code`. */
+export declare function requestError(code: LoraGraphQLErrorCode, message: string, cause?: unknown, extensions?: Record<string, unknown>): GraphQLError;

package/dist/execute/changes.d.ts

@@ -0,0 +1,61 @@
+import { MutationOperation } from '../model/types.js';
+export interface EntityRef {
+    /** Node type name. */
+    type: string;
+    /** Its @key value. */
+    key: unknown;
+}
+export interface RelationshipRef {
+    /** Relationship type, e.g. `FOLLOWS`. */
+    type: string;
+    /** `Owner.field` that declares it. */
+    field: string;
+    from: EntityRef;
+    to: EntityRef;
+}
+export interface WriteChange {
+    /** `EXTERNAL`: from the engine's change feed (`changeFeed: true`). */
+    operation: MutationOperation | "UPSERT" | "CYPHER" | "EXTERNAL";
+    /** When the change was committed (ISO-8601), set when it is emitted. */
+    timestamp?: string;
+    /**
+     * Stored properties before the write, for updated and deleted nodes of
+     * types with `@subscription(previousState: true)`.
+     */
+    before?: Array<{
+        type: string;
+        key: unknown;
+        properties: Record<string, unknown>;
+    }>;
+    /** The Mutation field that made the change. */
+    field: string;
+    created: EntityRef[];
+    updated: EntityRef[];
+    deleted: EntityRef[];
+    connected: RelationshipRef[];
+    disconnected: RelationshipRef[];
+    /**
+     * Every node whose observable state changed: created, updated and
+     * deleted nodes, and both ends of every relationship written. A
+     * response cache should invalidate by `types` too: lists, counts and
+     * connections change without naming an entity (see the Yoga example).
+     */
+    entities: EntityRef[];
+    /** Node types in `entities`: lists of these types may have changed. */
+    types: string[];
+    relationshipTypes: string[];
+    /**
+     * The write-set is unknown (a `@cypher` mutation): treat everything as
+     * changed.
+     */
+    broad: boolean;
+}
+export interface ReadSetLike {
+    labels: readonly string[];
+    relationships: readonly string[];
+}
+/**
+ * Whether a read with this read-set may observe the change. Label-level:
+ * a read of `:Festival` nodes is affected by any Festival write.
+ */
+export declare function affects(reads: ReadSetLike, change: WriteChange, labelsOf: (type: string) => readonly string[]): boolean;

package/dist/execute/cypher-mutation.d.ts

@@ -0,0 +1,4 @@
+import { FieldNode } from 'graphql';
+import { CypherField } from '../model/types.js';
+import { MutationEnv } from './mutate.js';
+export declare function executeCypherMutation(env: MutationEnv, field: CypherField, args: Record<string, unknown>, fieldNodes: readonly FieldNode[]): Promise<unknown>;

package/dist/execute/feed.d.ts

@@ -0,0 +1,10 @@
+import { LoraDriver } from '../driver.js';
+import { GraphModel } from '../model/types.js';
+import { WriteChange } from './changes.js';
+export declare class EngineFeed {
+    #private;
+    constructor(driver: LoraDriver, model: GraphModel, emit: (change: WriteChange) => void);
+    /** Subscribe; resolves once every later commit will be delivered. */
+    start(): Promise<void>;
+    stop(): void;
+}

package/dist/execute/mutate.d.ts

@@ -0,0 +1,57 @@
+import { FieldNode } from 'graphql';
+import { SelectionContext } from '../compile/selection.js';
+import { DriverTransaction, LoraDriver, QueryResult, Statement } from '../driver.js';
+import { GraphModel, NodeType } from '../model/types.js';
+import { MutationKind } from '../schema/mutations.js';
+import { WriteChange } from './changes.js';
+/** Computes a `@populatedBy` field. */
+export type PopulatedByCallback = (args: {
+    operation: "CREATE" | "UPDATE";
+    /** Node type and field being populated. */
+    type: string;
+    field: string;
+    key: unknown;
+    /** The node's input in this mutation. */
+    input: Record<string, unknown>;
+    /** The GraphQL context. */
+    context: unknown;
+}) => unknown;
+export interface MutationEnv {
+    model: GraphModel;
+    driver: LoraDriver;
+    selection: SelectionContext;
+    jwt: Record<string, unknown> | undefined;
+    /** The GraphQL context, for `$context` in rules and for callbacks. */
+    requestContext: unknown;
+    timeoutMs: number;
+    signal: AbortSignal | undefined;
+    degrees: ReadonlyMap<string, number>;
+    /** Most nodes one mutation may create or delete, nested ones included. */
+    maxBatch: number;
+    callbacks: Readonly<Record<string, PopulatedByCallback>>;
+    /**
+     * A caller-owned transaction: run inside it and leave the commit to the
+     * caller. A failed mutation rolls it back, so it is never half-applied.
+     */
+    transaction?: DriverTransaction | undefined;
+    /** Observes every statement, for logging and tests. */
+    onStatement?: ((statement: Statement) => void) | undefined;
+    /** Runs a statement under timing, tracing and metrics, when configured. */
+    observe?: ((statement: Statement, run: () => Promise<QueryResult>) => Promise<QueryResult>) | undefined;
+}
+/** Run `statement` in `tx`, reporting it before and observing it during. */
+export declare function runStatement(env: MutationEnv, tx: DriverTransaction, statement: Statement): Promise<QueryResult>;
+export interface MutationInfo {
+    nodesCreated: number;
+    nodesUpdated: number;
+    nodesDeleted: number;
+    relationshipsCreated: number;
+    relationshipsDeleted: number;
+}
+export interface MutationResult {
+    payload: unknown;
+    change: WriteChange;
+}
+export declare function executeMutation(env: MutationEnv, op: MutationKind, node: NodeType, args: Record<string, unknown>, fieldNodes: readonly FieldNode[], fieldName: string): Promise<MutationResult>;
+/** Turn engine constraint errors into CONSTRAINT_VIOLATION naming the field. */
+export declare function mapWriteError(model: GraphModel, err: unknown): unknown;

package/dist/execute/transaction.d.ts

@@ -0,0 +1,17 @@
+import { DriverTransaction, QueryResult } from '../driver.js';
+import { WriteChange } from './changes.js';
+export declare class LoraTransaction {
+    #private;
+    /** @internal Created by `LoraGraphQL.begin()`. */
+    constructor(tx: DriverTransaction, emit: (change: WriteChange) => void);
+    /** @internal The driver transaction statements run in. */
+    get driverTransaction(): DriverTransaction;
+    /** False once committed, rolled back, or failed. */
+    get isOpen(): boolean;
+    /** Run the application's own Cypher in the transaction. */
+    execute(query: string, params?: Record<string, unknown>): Promise<QueryResult>;
+    /** @internal A mutation's write-set, reported when the transaction commits. */
+    record(change: WriteChange): void;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/dist/guards.d.ts

@@ -0,0 +1,42 @@
+import { ParseOptions, ValidationRule } from 'graphql';
+export interface DocumentGuards {
+    /** Deepest field nesting, fragments followed. Default 12. */
+    maxDepth?: number;
+    /** Aliased fields in one document. Default 30. */
+    maxAliases?: number;
+    /** Root fields in one operation. Default 20. */
+    maxRootFields?: number;
+    /** Lexer tokens in one document, checked while parsing. Default 5000. */
+    maxTokens?: number;
+    /**
+     * Allow `__schema` and `__type`. Default: off when `NODE_ENV` is
+     * `production`, on otherwise. `__typename` is always allowed.
+     */
+    introspection?: boolean;
+}
+export declare const DEFAULT_GUARDS: {
+    readonly maxDepth: 12;
+    readonly maxAliases: 30;
+    readonly maxRootFields: 20;
+    readonly maxTokens: 5000;
+};
+export declare function resolveGuards(guards?: DocumentGuards): Required<DocumentGuards>;
+/** Validation rules for the guards, to add to the standard ones. */
+export declare function validationRules(guards?: DocumentGuards): ValidationRule[];
+/** Parse options for the guards (the token limit). */
+export declare function parseOptions(guards?: DocumentGuards): ParseOptions;
+/**
+ * The guards as an Envelop plugin, for GraphQL Yoga and other Envelop
+ * servers: the token limit wraps `parse`, the rest are validation rules.
+ * Typed structurally, so the package does not depend on Envelop.
+ */
+export declare function envelopPlugin(guards?: DocumentGuards): {
+    onParse({ parseFn, setParseFn, }: {
+        parseFn: (source: unknown, options?: ParseOptions) => unknown;
+        setParseFn: (fn: (source: unknown, options?: ParseOptions) => unknown) => void;
+    }): void;
+    onValidate({ addValidationRule, }: {
+        addValidationRule: (rule: ValidationRule) => void;
+    }): void;
+};
+export declare function nodeEnv(): string | undefined;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { LoraGraphQL, type AssertSchemaOptions, type CheckOptions, type CheckReport, type CostEvent, type DatabaseErrorEvent, type ExecuteArgs, type LoraGraphQLContext, type LoraGraphQLOptions, type SchemaAssertion, type StatementEvent, } from './lora-graphql.js';
+export { loraDriver, type DriverTransaction, type LoraDatabaseLike, type LoraDriver, type QueryPlan, type QueryResult, type RunOptions, type Statement, } from './driver.js';
+export { directiveTypeDefs } from './model/directives.js';
+export { buildModel, type ModelOptions } from './model/build.js';
+export type * from './model/types.js';
+export { inferRequirements, requirementDdl, type SchemaRequirement, } from './analyze/indexes.js';
+export { checkPlans, scanExpands, type PlanFinding, type PlanReport, } from './analyze/plans.js';
+export type { DegreeStats, Statistics } from './analyze/statistics.js';
+export type { CypherFinding } from './analyze/cypher-check.js';
+export { diffSchemas, type ApiChange, type SchemaDiff, } from './analyze/diff.js';
+export type { CompiledRead, ReadSet, SeekExpectation } from './compile/read.js';
+export type { EntityRef, RelationshipRef, WriteChange, } from './execute/changes.js';
+export type { MutationInfo, PopulatedByCallback } from './execute/mutate.js';
+export type { MutationKind } from './schema/mutations.js';
+export type { ChangeEvent } from './schema/build.js';
+export { LoraTransaction } from './execute/transaction.js';
+export { ModelError, formatProblem, type LoraGraphQLErrorCode, type ModelProblem, } from './errors.js';
+export { toGlobalId, fromGlobalId } from './schema/global-id.js';
+export type { Attributes, MetricsLike, ObservabilityOptions, SpanLike, StatementEndEvent, TracerLike, } from './observe.js';
+export { schemaHash, type ManifestOperation, type OperationManifest, } from './codegen.js';
+export { envelopPlugin, parseOptions, validationRules, DEFAULT_GUARDS, type DocumentGuards, } from './guards.js';

package/dist/index.js

@@ -0,0 +1,24 @@
+import { D as e, L as r, a as o, M as l, b as i, c as d, d as n, e as t, f, g as m, i as p, l as c, p as h, r as D, s as b, h as u, t as v, v as L } from "./driver-C8vA5fV-.js";
+import { d as x } from "./diff-BVP1Jzh3.js";
+export {
+  e as DEFAULT_GUARDS,
+  r as LoraGraphQL,
+  o as LoraTransaction,
+  l as ModelError,
+  i as buildModel,
+  d as checkPlans,
+  x as diffSchemas,
+  n as directiveTypeDefs,
+  t as envelopPlugin,
+  f as formatProblem,
+  m as fromGlobalId,
+  p as inferRequirements,
+  c as loraDriver,
+  h as parseOptions,
+  D as requirementDdl,
+  b as scanExpands,
+  u as schemaHash,
+  v as toGlobalId,
+  L as validationRules
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/lora-graphql.d.ts

@@ -0,0 +1,291 @@
+import { DocumentNode, ExecutionResult, GraphQLSchema, GraphQLFieldResolver, GraphQLScalarType, ValidationRule } from 'graphql';
+import { CypherFinding } from './analyze/cypher-check.js';
+import { SchemaRequirement } from './analyze/indexes.js';
+import { PlanReport } from './analyze/plans.js';
+import { Statistics } from './analyze/statistics.js';
+import { CompiledRead, ReadSet } from './compile/read.js';
+import { LoraDriver, Statement } from './driver.js';
+import { WriteChange } from './execute/changes.js';
+import { LoraTransaction } from './execute/transaction.js';
+import { PopulatedByCallback } from './execute/mutate.js';
+import { OperationManifest } from './codegen.js';
+import { envelopPlugin, DocumentGuards } from './guards.js';
+import { ModelOptions } from './model/build.js';
+import { ObservabilityOptions } from './observe.js';
+import { GraphModel, ModelWarning } from './model/types.js';
+export interface LoraGraphQLOptions extends ModelOptions, ObservabilityOptions {
+    /** Annotated SDL: the graph model and the API in one document. */
+    typeDefs: string | DocumentNode;
+    driver: LoraDriver;
+    /** Timeout for every statement, in milliseconds. Default 10 000; 0 disables. */
+    timeoutMs?: number;
+    /**
+     * Reject a root field whose estimated rows touched exceed this, before
+     * it runs. The estimate multiplies page sizes through nested lists,
+     * capped by relationship degrees from `analyze()` or `@cardinality`.
+     * Default 50 000; `Infinity` disables.
+     */
+    maxCost?: number;
+    /**
+     * The cost limit for one request, from its context (for example by
+     * user or plan). Undefined falls back to `maxCost`.
+     */
+    budget?: (context: unknown) => number | undefined;
+    /** Called with every root field's cost estimate, before it runs. */
+    onCost?: (event: CostEvent) => void;
+    /**
+     * The request's verified claims, from the GraphQL context. Default:
+     * `context.jwt`. The library never verifies tokens: do that in the
+     * server and put the claims in the context.
+     */
+    jwt?: (context: unknown) => Record<string, unknown> | undefined;
+    /**
+     * Most nodes one mutation may create or delete, nested ones included.
+     * Default 1000: larger imports belong in a Cypher load, not a GraphQL
+     * request. Also the default `limit` of bulk updates and deletes.
+     */
+    maxBatch?: number;
+    /**
+     * Changes a `changes()` consumer or subscriber may fall behind before it
+     * is ended with an error. Default 1000.
+     */
+    maxQueuedChanges?: number;
+    /** Named callbacks for `@populatedBy(callback:)`. */
+    callbacks?: Record<string, PopulatedByCallback>;
+    /**
+     * Implementations of custom scalars declared with `@storedAs`, e.g. one
+     * that validates e-mail addresses. Without one a scalar passes through.
+     */
+    scalars?: Record<string, GraphQLScalarType>;
+    /**
+     * Feed subscriptions and `changes()` from the engine's committed change
+     * feed (lora-node `db.changes()`): writes from every path and process,
+     * in commit order. `onWrite` still reports this instance's mutations,
+     * and `previousState` needs them. Default false.
+     */
+    changeFeed?: boolean;
+    /**
+     * Resolvers of `@customResolver` fields, by type and field name. The
+     * source holds the node's selected fields plus the field's `requires`.
+     */
+    resolvers?: Record<string, Record<string, GraphQLFieldResolver<Record<string, unknown>, unknown>>>;
+    /** Called with every statement before it runs; for logging and tests. */
+    onStatement?: (event: StatementEvent) => void;
+    /**
+     * Hide database error details from clients: they get
+     * `extensions.code` `DATABASE_ERROR` and an `id`, and `onError` gets the
+     * engine's message. Default: on when `NODE_ENV` is `production`.
+     */
+    maskErrors?: boolean;
+    /** Called with every database error, masked or not. */
+    onError?: (event: DatabaseErrorEvent) => void;
+    /**
+     * Limits on the documents `execute()` and `persist()` accept: depth,
+     * aliases, root fields, tokens, introspection. `false` turns them off.
+     * For other servers use `validationRules()` or `envelopPlugin()`.
+     */
+    guards?: DocumentGuards | false;
+    /**
+     * Make `execute()` refuse `source` and run only persisted operations
+     * by `id`. Default false.
+     */
+    persistedOnly?: boolean;
+}
+export interface CostEvent {
+    field: string;
+    /** Estimated rows this root field touches. */
+    cost: number;
+    /** Estimated rows of the operation so far, this field included. */
+    total: number;
+    /** The limit that applies: `budget(context)` or `maxCost`. */
+    limit: number;
+    context: unknown;
+}
+export interface DatabaseErrorEvent {
+    /** Correlation id, also in the client error's `extensions.id`. */
+    id: string;
+    /** The root field that failed. */
+    field: string;
+    /** The engine's message, which may name labels, properties and Cypher. */
+    message: string;
+    /** The error as thrown by the driver. */
+    error: unknown;
+}
+export interface StatementEvent {
+    field: string;
+    statement: Statement;
+}
+/** Per-request options read from the GraphQL context, when present. */
+export interface LoraGraphQLContext {
+    /** Verified claims; enables @authentication and @authorization. */
+    jwt?: Record<string, unknown>;
+    /** Cancels the request's statements when aborted. */
+    signal?: AbortSignal;
+    /**
+     * Run in this transaction (from `lora.begin()`) instead of one per
+     * field: the caller commits, together with its own Cypher.
+     */
+    transaction?: LoraTransaction;
+}
+export interface AssertSchemaOptions {
+    /** Create what is missing instead of only reporting it. */
+    create?: boolean;
+}
+export interface SchemaAssertion {
+    required: SchemaRequirement[];
+    missing: SchemaRequirement[];
+    created: SchemaRequirement[];
+}
+export interface CheckOptions {
+    /**
+     * Flag statements whose largest engine row estimate (from graph
+     * statistics) exceeds this. Off by default: estimates ignore a LIMIT
+     * that stops an index-ordered scan early.
+     */
+    rowBudget?: number;
+    /** Operations to compile and plan-check (S2), with example variables. */
+    operations?: Array<{
+        name?: string;
+        document: string | DocumentNode;
+        variables?: Record<string, unknown>;
+    }>;
+}
+export interface CheckReport {
+    /** True when nothing below is a failure. */
+    ok: boolean;
+    /** Model warnings, e.g. an unused @cypher argument. */
+    warnings: readonly ModelWarning[];
+    /** @cypher statements the engine rejects or that write from a query. */
+    cypher: CypherFinding[];
+    /** Constraints and indexes the database lacks. */
+    missing: SchemaRequirement[];
+    /** Indexes the database has that no part of the API needs. */
+    unused: Array<{
+        name: string;
+        type: string;
+        labels: string[];
+        properties: string[];
+    }>;
+    /** Schema lint: valid but costly or risky choices (not failures). */
+    lint: readonly ModelWarning[];
+    /** Plan findings per operation and root field. */
+    plans: Array<{
+        operation: string;
+        field: string;
+        reports: PlanReport[];
+    }>;
+    /** Operations that failed to compile. */
+    errors: Array<{
+        operation: string;
+        message: string;
+    }>;
+}
+export interface ExecuteArgs {
+    /** The document, or `id` of a persisted operation. */
+    source?: string;
+    id?: string;
+    variables?: Record<string, unknown>;
+    operationName?: string;
+    context?: unknown;
+}
+export declare class LoraGraphQL {
+    #private;
+    readonly model: GraphModel;
+    constructor(options: LoraGraphQLOptions);
+    /** The configured document guards as validation rules. */
+    validationRules(): ValidationRule[];
+    /** The configured document guards as an Envelop / Yoga plugin. */
+    envelopPlugin(): ReturnType<typeof envelopPlugin>;
+    /** The executable schema, for any graphql-js server. */
+    getSchema(): GraphQLSchema;
+    /** The client-facing SDL: generated types only, no model directives. */
+    printPublicSchema(): string;
+    /** Constraints and indexes the API needs (S1), with the reason for each. */
+    requirements(): SchemaRequirement[];
+    /**
+     * Verify the database has every constraint and index the API needs;
+     * with `create`, add what is missing. Idempotent. Runs one DDL
+     * statement at a time: LoraDB rejects schema commands in transactions.
+     */
+    assertSchema(options?: AssertSchemaOptions): Promise<SchemaAssertion>;
+    /**
+     * Sample node counts and relationship degrees (S6). Cost estimates then
+     * use each relationship's p99 degree instead of its page limit.
+     */
+    analyze(options?: {
+        sample?: number;
+    }): Promise<Statistics>;
+    /** Use statistics gathered earlier, e.g. by the CLI. */
+    useStatistics(stats: Statistics): void;
+    get statistics(): Statistics | undefined;
+    /**
+     * The CI gate: @cypher statements plan, the database has what the API
+     * needs, and each operation's statements seek where they should.
+     */
+    check(options?: CheckOptions): Promise<CheckReport>;
+    /**
+     * Compile a query without running it: one entry per root field, with its
+     * statements, parameters, read-set, cost and expected access path.
+     */
+    compile(document: string | DocumentNode, variables?: Record<string, unknown>, options?: {
+        operationName?: string;
+        context?: unknown;
+    }): Array<{
+        field: string;
+        compiled: CompiledRead;
+    }>;
+    /** Compile a query and check every statement's plan (S2). */
+    explain(document: string | DocumentNode, variables?: Record<string, unknown>, options?: {
+        operationName?: string;
+        context?: unknown;
+        rowBudget?: number | undefined;
+    }): Promise<Array<{
+        field: string;
+        reports: PlanReport[];
+    }>>;
+    /**
+     * Register persisted operations by id. Every document is parsed and
+     * validated now, so a broken one fails at startup; at request time an
+     * id is looked up and executed without parsing or validating.
+     */
+    persist(operations: Record<string, string>): void;
+    /**
+     * Validate persisted operations (id → source) into a manifest for
+     * `loadManifest()`, built once at build time (`lora-graphql compile`).
+     */
+    buildManifest(operations: Record<string, string>): OperationManifest;
+    /** TypeScript types for a manifest's variables and results. */
+    generateTypes(manifest: OperationManifest): string;
+    /**
+     * Register a manifest's operations as persisted operations, without
+     * parsing or validating them again. Refused when the manifest was built
+     * for another schema.
+     */
+    loadManifest(manifest: OperationManifest): void;
+    /**
+     * Execute an operation against the schema. Parsed and validated
+     * documents are cached by source text; persisted ones by id.
+     */
+    execute(args: ExecuteArgs): Promise<ExecutionResult>;
+    /** Called after every committed mutation with its exact write-set. */
+    onWrite(listener: (change: WriteChange) => void): () => void;
+    /**
+     * Committed writes as an async iterator, e.g. for a subscription
+     * resolver. Only writes made through this instance are seen.
+     */
+    changes(options?: {
+        signal?: AbortSignal;
+        maxQueued?: number;
+    }): AsyncIterableIterator<WriteChange>;
+    /** Whether a read with this read-set may observe the change. */
+    affects(reads: ReadSet, change: WriteChange): boolean;
+    /**
+     * Open a transaction the caller owns. Put it in the GraphQL context as
+     * `transaction`: every operation of those requests runs in it, next to
+     * the application's own `tx.execute(cypher)`. Nothing is visible to
+     * others, and no change event fires, until `tx.commit()`.
+     */
+    begin(): Promise<LoraTransaction>;
+    /** Stop the engine change feed (with `changeFeed: true`). */
+    close(): void;
+}