@bjornpagen/bumbledb 1.3.1 → 2.0.0-rc.1

package/src/native/binding.d.ts

@@ -0,0 +1,996 @@
+/* Generated by crates/bumbledb-node/dts.sh from the napi annotations. Do not edit. */
+
+declare const handle: unique symbol
+
+export interface ChangesCursorHandle {
+  readonly [handle]: 'ChangesCursorHandle'
+}
+
+export interface ChangesHandle {
+  readonly [handle]: 'ChangesHandle'
+}
+
+export interface CursorHandle {
+  readonly [handle]: 'CursorHandle'
+}
+
+export interface DbHandle {
+  readonly [handle]: 'DbHandle'
+}
+
+export interface DirectoryHandle {
+  readonly [handle]: 'DirectoryHandle'
+}
+
+export interface DraftHandle {
+  readonly [handle]: 'DraftHandle'
+}
+
+export interface HostedHandle {
+  readonly [handle]: 'HostedHandle'
+}
+
+export interface OperationHandle {
+  readonly [handle]: 'OperationHandle'
+}
+
+export interface PreparedHandle {
+  readonly [handle]: 'PreparedHandle'
+}
+
+export interface QueryHandle {
+  readonly [handle]: 'QueryHandle'
+}
+
+export interface ResultHandle {
+  readonly [handle]: 'ResultHandle'
+}
+
+export interface RuntimeHandle {
+  readonly [handle]: 'RuntimeHandle'
+}
+
+export interface SchemaHandle {
+  readonly [handle]: 'SchemaHandle'
+}
+
+export interface SnapshotHandle {
+  readonly [handle]: 'SnapshotHandle'
+}
+
+export interface T {
+  readonly [handle]: 'T'
+}
+
+export interface WitnessHandle {
+  readonly [handle]: 'WitnessHandle'
+}
+
+
+export declare class ExternalObject<T> {
+  readonly '': {
+    readonly '': unique symbol
+    [K: symbol]: T
+  }
+}
+
+/**
+ * One apply outcome. `Committed.changed` is false when the change set
+ * matched the committed state (the generation did not move); `Moved` means
+ * the expected generation was not the current one.
+ */
+export type ApplyOutcome =
+  | { _tag: 'Committed'; generation: bigint; changed: boolean }
+  | { _tag: 'Rejected'; violations: Array<ViolationOut> }
+  | { _tag: 'Moved'; witnessed: bigint; current: bigint }
+
+export interface AtomIn {
+  source: AtomSourceIn
+  bindings: Array<BindingIn>
+}
+
+export type AtomSourceIn =
+  | { kind: 'Edb'; relation: number }
+  | { kind: 'Interior'; interior: number }
+
+export interface BindingIn {
+  field: number
+  term: TermIn
+}
+
+export type BoundSpecIn =
+  | { kind: 'Lit'; value: string }
+  | { kind: 'Field'; field: string }
+  | { kind: 'Duration'; field: string }
+
+export type BucketOut = 'Log' | 'Checkpoints'
+
+/**
+ * One bundled migration: its name, content hash (64 hex digits) and the
+ * schema spec it migrates to. The first step is the initial schema.
+ */
+export interface BundleStepIn {
+  name: string
+  hash: string
+  schema: SchemaSpecIn
+}
+
+export type CapacityWindowSpecIn =
+  | { kind: 'Exact'; n: BoundSpecIn }
+  | { kind: 'Range'; lo: BoundSpecIn; hi: BoundSpecIn }
+  | { kind: 'Floor'; lo: BoundSpecIn }
+
+/** A capacity ceiling; `Unbounded` is the `*` window end. */
+export type CeilingOut =
+  | { _tag: 'Unbounded' }
+  | { _tag: 'Lit'; value: bigint }
+  | { _tag: 'TargetField'; field: number }
+  | { _tag: 'TargetDuration'; field: number }
+
+/** One tagged data-plane value: an execute param's scalar, or a set member. */
+export type CellIn =
+  | { kind: 'Bool'; value: boolean }
+  | { kind: 'U64'; value: bigint }
+  | { kind: 'I64'; value: bigint }
+  | { kind: 'F64'; value: number }
+  | { kind: 'String'; value: string }
+  | { kind: 'Uuid'; value: string }
+  | { kind: 'FixedBytes'; value: Uint8Array }
+  | { kind: 'IntervalU64'; start: bigint; end: bigint }
+  | { kind: 'IntervalI64'; start: bigint; end: bigint }
+  | { kind: 'IntervalF64'; start: number; end: number }
+
+export interface CellInterval {
+  start: bigint | number
+  end: bigint | number
+}
+
+/**
+ * One row cell as JavaScript sees it: `u64`/`i64` as `bigint`, `f64` as
+ * `number`, text and UUIDs as `string`, bytes as `Uint8Array`, intervals as
+ * `{ start, end }` in their element's representation.
+ */
+export type CellValue = boolean | bigint | number | string | Uint8Array | CellInterval
+
+export interface ChangeCounts {
+  added: bigint
+  removed: bigint
+}
+
+export type ChangeKindOut = 'Add' | 'Remove'
+
+/** One change record: an addition or removal of one row of `relation`. */
+export interface ChangeRecordOut {
+  relation: number
+  kind: ChangeKindOut
+  values: Array<CellValue>
+}
+
+/** A sealed change set and its summary. */
+export interface ChangesOut {
+  changes: ExternalObject<ChangesHandle>
+  fingerprint: string
+  counts: ChangeCounts
+  byteLength: bigint
+}
+
+/** One closed relation row: its handle, declaration-order id and columns. */
+export interface ClosedRowOut {
+  handle: string
+  id: bigint
+  values: Array<NamedValueOut>
+}
+
+export interface ClosedSpecIn {
+  newtype: string
+  rows: Array<RowSpecIn>
+}
+
+/**
+ * A close or cancel outcome: joined, timed out with work still
+ * outstanding, or failed (cleanup capacity exhausted or teardown failed).
+ */
+export type CloseOut =
+  | { _tag: 'Closed' }
+  | { _tag: 'Incomplete'; outstanding: InspectionOut }
+  | { _tag: 'Failed' }
+
+/** A comparison operator; `Allen.mask` is a nonzero 13-bit relation set. */
+export type CmpOpIn =
+  | { kind: 'Eq' }
+  | { kind: 'Ne' }
+  | { kind: 'Lt' }
+  | { kind: 'Le' }
+  | { kind: 'Gt' }
+  | { kind: 'Ge' }
+  | { kind: 'PointIn' }
+  | { kind: 'Allen'; mask: number }
+
+/** Compile one schema spec (the schema file's JSON) into a validated handle. */
+export declare function compileSchema(specJson: string): SchemaCompiled
+
+export type ConditionIn =
+  | { kind: 'Leaf'; op: CmpOpIn; lhs: TermIn; rhs: TermIn }
+  | { kind: 'And'; children: Array<ConditionIn> }
+  | { kind: 'Or'; children: Array<ConditionIn> }
+
+/**
+ * One relation a migration copies unchanged: `target` at the new schema
+ * from `source` at the old one.
+ */
+export interface CopyPair {
+  target: number
+  source: number
+}
+
+/** Bounded database diagnostics, never rows. */
+export interface DbInspection {
+  generation: bigint
+  diskBytes: bigint
+  retainedOperations: bigint
+}
+
+/** A database open outcome. Refusals are domain outcomes, not failures. */
+export type DbOpened =
+  | { _tag: 'Opened'; db: ExternalObject<DbHandle> }
+  | { _tag: 'Rejected'; violations: Array<ViolationOut> }
+  | { _tag: 'FingerprintMismatch'; message: string }
+  | { _tag: 'DestinationExists'; message: string }
+
+export interface DoneOut {
+  ticket: bigint
+  settled: SettledOut
+}
+
+export declare function engineVersion(): string
+
+/**
+ * A rejection's evidence, rendered against the schema it was judged under
+ * when this code bundles it.
+ */
+export interface EvidenceOut {
+  violations: Array<ViolationOut>
+  bytes: Uint8Array
+}
+
+/** One fact a violation cites, by relation and field names. */
+export interface FactOut {
+  relation: string
+  fields: Array<NamedValueOut>
+}
+
+export interface FieldOut {
+  name: string
+  id: number
+  valueType: ValueTypeOut
+  newtype?: string
+}
+
+export interface FieldSpecIn {
+  name: string
+  valueType: ValueTypeIn
+  newtype?: string
+}
+
+export type FindTermIn =
+  | { kind: 'Var'; var: number }
+  | { kind: 'Compute'; expr: ScalarExprIn }
+  | { kind: 'Segments'; op: SegmentOpIn; left: number; right: number }
+  | { kind: 'Count' }
+  | { kind: 'Aggregate'; op: FoldOpIn; over: number }
+  | { kind: 'Pack'; over: number }
+
+export type FixedIntervalElementIn = 'U64' | 'I64'
+
+export type FoldOpIn = 'Sum' | 'Mean' | 'Min' | 'Max'
+
+export type HeadOpIn = 'Sum' | 'Mean' | 'Min' | 'Max' | 'Count' | 'Pack'
+
+/**
+ * The decided state: identity, position, revision, schema fingerprint, the
+ * migration ledger, and the store-time end of a freeze.
+ */
+export interface HeadOut {
+  database: string
+  seq: bigint
+  revision: bigint
+  schema: string
+  applied: Array<MigrationOut>
+  rejected: Array<MigrationOut>
+  frozenUntil?: bigint
+}
+
+export type HeadTermIn =
+  | { kind: 'Var' }
+  | { kind: 'Compute' }
+  | { kind: 'Aggregate'; op: HeadOpIn }
+
+/**
+ * Close the machine and its cache. Step `Close` first to settle every
+ * pending ticket.
+ */
+export declare function hostedClose(hosted: ExternalObject<HostedHandle>, callback: (arg: CloseOut) => void): void
+
+/** A machine input that carries no change set. */
+export type HostedInput =
+  | { _tag: 'Open'; ticket: bigint }
+  | { _tag: 'Sync'; ticket: bigint }
+  | { _tag: 'Resolve'; ticket: bigint; request: string }
+  | { _tag: 'Freeze'; ticket: bigint; leaseMillis: bigint }
+  | { _tag: 'Close' }
+
+/**
+ * Apply bundled migration `step`, computed at `base` (the head the rows
+ * were computed from): `copy` relations carried over unchanged plus the
+ * computed `rows` at the new schema.
+ */
+export declare function hostedMigrate(hosted: ExternalObject<HostedHandle>, ticket: bigint, step: number, base: bigint, copy: Array<CopyPair>, rows: ExternalObject<ChangesHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+/**
+ * Open the hosted database whose cache lives in `childName` of an owned
+ * directory. `openJson` is a `HostedOpenIn`.
+ */
+export declare function hostedOpen(directory: ExternalObject<DirectoryHandle>, childName: string, openJson: string, callback: () => void): ExternalObject<OperationHandle>
+
+/**
+ * Everything a hosted database opens with. `seed` (32 hex digits) is
+ * random per process; `create` (32 hex digits) is the identity a new
+ * database gets when its log is empty, absent to refuse creation.
+ */
+export interface HostedOpenIn {
+  bundle: Array<BundleStepIn>
+  seed: string
+  create?: string
+  probeWindow: number
+  checkpointEvery: string
+  checkpointKeep: number
+  maxEntryBytes: number
+}
+
+/**
+ * Feed back one completed store request. `date` is the response's `Date`
+ * header in Unix milliseconds.
+ */
+export declare function hostedRespond(hosted: ExternalObject<HostedHandle>, id: bigint, date: bigint | undefined | null, outcome: IoOutcomeIn, callback: () => void): ExternalObject<OperationHandle>
+
+/** Feed back one `GetMemory` request that found its object. */
+export declare function hostedRespondBody(hosted: ExternalObject<HostedHandle>, id: bigint, date: bigint | undefined | null, lastModified: bigint, body: Uint8Array, callback: () => void): ExternalObject<OperationHandle>
+
+/**
+ * Pin a snapshot of the cache's current state; take it with
+ * `runtimeSnapshotTake`. Refuses `ClosedHandle` before the first state.
+ */
+export declare function hostedSnapshot(hosted: ExternalObject<HostedHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function hostedStep(hosted: ExternalObject<HostedHandle>, input: HostedInput, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function hostedStepTake(handle: ExternalObject<OperationHandle>): StepOut
+
+/**
+ * Submit one command: the request id (32 hex digits) is its idempotency
+ * key; `revision` present requires exactly that committed revision.
+ */
+export declare function hostedSubmit(hosted: ExternalObject<HostedHandle>, ticket: bigint, request: string, revision: bigint | undefined | null, changes: ExternalObject<ChangesHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function hostedTake(handle: ExternalObject<OperationHandle>): ExternalObject<HostedHandle>
+
+/** The relations bundled migration `step` copies unchanged by default. */
+export declare function hostedUnchanged(hosted: ExternalObject<HostedHandle>, step: number): Array<CopyPair>
+
+/** Bounded runtime bookkeeping counts. */
+export interface InspectionOut {
+  phase: Phase
+  queued: bigint
+  active: bigint
+  retained: bigint
+  owners: bigint
+  databases: bigint
+  natives: bigint
+}
+
+export interface InteriorIn {
+  rules: Array<RuleIn>
+}
+
+export type IntervalElementIn = 'U64' | 'I64' | 'F64'
+
+export type IntervalElementOut = 'U64' | 'I64' | 'F64'
+
+/** The outcome of one store request other than a body read. */
+export type IoOutcomeIn =
+  | { _tag: 'Saved'; lastModified: bigint }
+  | { _tag: 'Missing' }
+  | { _tag: 'Created' }
+  | { _tag: 'Occupied' }
+  | { _tag: 'Keys'; keys: Array<string> }
+  | { _tag: 'Deleted' }
+  | { _tag: 'Failed' }
+
+/** One store request; `key` is relative to the database's prefix. */
+export interface IoRequestOut {
+  id: bigint
+  bucket: BucketOut
+  key: string
+  op: OpOut
+}
+
+/**
+ * One judgment of the change set against the current `generation`; the
+ * database never changes.
+ */
+export type JudgeOutcome =
+  | { _tag: 'Admitted'; generation: bigint; changes: ChangeCounts }
+  | { _tag: 'Rejected'; generation: bigint; violations: Array<ViolationOut> }
+  | { _tag: 'Moved'; witnessed: bigint; current: bigint }
+
+/** One selection binding's right side; a literal set reads disjunctively. */
+export type LiteralSetSpecIn =
+  | { kind: 'One'; literal: LiteralSpecIn }
+  | { kind: 'Many'; literals: Array<LiteralSpecIn> }
+
+/** A literal as spelled: a plain value, or a closed relation's handle. */
+export type LiteralSpecIn =
+  | { kind: 'Value'; value: ValueIn }
+  | { kind: 'Handle'; handle: string }
+
+/**
+ * A JSON input that does not match its wire type: the serde path to the
+ * offending node (for example `rules[0].atoms[2].bindings`) and why.
+ */
+export interface Malformed {
+  path: string
+  message: string
+}
+
+export interface MigrationOut {
+  name: string
+  hash: string
+}
+
+/** One named cell of a rendered fact or closed row. */
+export interface NamedValueOut {
+  name: string
+  value: CellValue
+}
+
+export type NumericCastIn = 'ToF64' | 'ToF64Exact' | 'ToI64Exact' | 'ToU64Exact'
+
+/**
+ * One store operation. `GetFile` downloads into `path`; `PutFile` uploads
+ * the file at `path`; puts are create-only (`If-None-Match: *`).
+ */
+export type OpOut =
+  | { _tag: 'GetMemory' }
+  | { _tag: 'GetFile'; path: string }
+  | { _tag: 'PutBytes'; bytes: Uint8Array }
+  | { _tag: 'PutFile'; path: string }
+  | { _tag: 'List'; startAfter?: string; maxKeys: number }
+  | { _tag: 'Delete' }
+
+export type OutcomeOut =
+  | { _tag: 'Committed'; added: bigint; removed: bigint }
+  | { _tag: 'NoChange' }
+  | { _tag: 'PreconditionFailed'; expected: bigint; observed: bigint }
+  | { _tag: 'InvariantRejected'; evidence: EvidenceOut }
+
+/** One execute param, positional by `ParamId`. */
+export type ParamIn = CellIn | ParamSetIn
+
+/** A set param: membership in any of `values`. */
+export interface ParamSetIn {
+  kind: 'Set'
+  values: Array<CellIn>
+}
+
+export type Phase = 'Open' | 'Closing' | 'Closed'
+
+/**
+ * The engine's refusal: `code` is its `ValidationError` variant, `refusal`
+ * the cited position's specific refusal (for example `Field` with
+ * `Unknown`, `Comparison` with `Unordered.Interval`), plus whichever
+ * rule-local coordinates it cites. `comparison` indexes the rule's
+ * flattened comparisons.
+ */
+export interface QueryDiagnostic {
+  code: string
+  refusal?: string
+  message: string
+  rule?: number
+  atom?: number
+  find?: number
+  field?: number
+  relation?: number
+  var?: number
+  param?: number
+  comparison?: number
+  interior?: number
+}
+
+export interface QueryIn {
+  interiors: Array<InteriorIn>
+  head: Array<HeadTermIn>
+  rules: Array<RuleIn>
+  rec?: RecIn
+}
+
+export type QueryValidated =
+  | { _tag: 'Valid'; query: ExternalObject<QueryHandle> }
+  | { _tag: 'Invalid'; diagnostic: QueryDiagnostic }
+  | { _tag: 'Malformed'; path: string; message: string }
+
+/** One request's durable decision; `seq` is the read-your-writes bookmark. */
+export interface ReceiptOut {
+  request: string
+  command: string
+  seq: bigint
+  revision: bigint
+  outcome: OutcomeOut
+}
+
+/** A recursive stage: nonempty base and step arms. */
+export interface RecIn {
+  base: Array<RecRuleIn>
+  rec: Array<RecStepIn>
+}
+
+export interface RecRuleIn {
+  finds: Array<number>
+  atoms: Array<AtomIn>
+  conditions: Array<ConditionIn>
+}
+
+/** A recursive step: `selfBindings` binds the stage's own previous output. */
+export interface RecStepIn {
+  finds: Array<number>
+  selfBindings: Array<BindingIn>
+  atoms: Array<AtomIn>
+  conditions: Array<ConditionIn>
+}
+
+/**
+ * Why a ticket settled without its effect. Every refusal of a submit except
+ * `Unknown` proves the log does not decide the command.
+ */
+export type RefusalOut =
+  | { _tag: 'NotOpen' }
+  | { _tag: 'Closed' }
+  | { _tag: 'NotFound' }
+  | { _tag: 'Frozen'; deadline: bigint }
+  | { _tag: 'SchemaAdvanced' }
+  | { _tag: 'MigrationPending'; next: number }
+  | { _tag: 'MigrationRejected'; migration: MigrationOut; evidence: EvidenceOut }
+  | { _tag: 'MigrationsDiverged'; index: number }
+  | { _tag: 'NotPending' }
+  | { _tag: 'Stale'; head: bigint }
+  | { _tag: 'RequestReused'; request: string; command: string }
+  | { _tag: 'ForeignSchema' }
+  | { _tag: 'TooLarge' }
+  | { _tag: 'Unknown' }
+  | { _tag: 'NotSubmitted' }
+  | { _tag: 'Cache'; message: string }
+  | { _tag: 'Corrupt'; seq: bigint }
+
+export interface RelationOut {
+  name: string
+  id: number
+  fields: Array<FieldOut>
+  extension?: Array<ClosedRowOut>
+}
+
+/** One relation; `closed` present declares it closed. */
+export interface RelationSpecIn {
+  name: string
+  fields: Array<FieldSpecIn>
+  closed?: ClosedSpecIn
+}
+
+export type RoundingIn = 'TowardZero' | 'NearestTiesAwayFromZero' | 'NearestTiesToEven'
+
+export interface RowSpecIn {
+  handle: string
+  values: Array<LiteralSpecIn>
+}
+
+export interface RuleIn {
+  finds: Array<FindTermIn>
+  atoms: Array<AtomIn>
+  negated: Array<AtomIn>
+  conditions: Array<ConditionIn>
+}
+
+export declare function runtimeApplyTake(handle: ExternalObject<OperationHandle>): ApplyOutcome
+
+/**
+ * Cancel the next payload publication between producing a page and
+ * accepting its delivery. A page already accepted is kept.
+ */
+export declare function runtimeArmPublicationCancel(handle: ExternalObject<RuntimeHandle>): void
+
+export declare function runtimeBytesTake(handle: ExternalObject<OperationHandle>): Uint8Array
+
+export declare function runtimeCancel(handle: ExternalObject<OperationHandle>, callback: (arg: CloseOut) => void): void
+
+/** One page of change records; `null` is the end of the cursor. */
+export declare function runtimeChangePageTake(handle: ExternalObject<OperationHandle>): Array<ChangeRecordOut> | null
+
+/** The change set's canonical bytes. */
+export declare function runtimeChangesBytes(handle: ExternalObject<ChangesHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeChangesClose(handle: ExternalObject<ChangesHandle>, callback: (arg: CloseOut) => void): void
+
+/**
+ * Compose two change sets into one (`left` then `right`). The first stage
+ * retains only an `Arc` share, then returns its worker immediately.
+ */
+export declare function runtimeChangesCompose(left: ExternalObject<ChangesHandle>, right: ExternalObject<ChangesHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+/** Open a fresh read position over the change set's records. */
+export declare function runtimeChangesCursor(handle: ExternalObject<ChangesHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeChangesCursorClose(handle: ExternalObject<ChangesCursorHandle>, callback: (arg: CloseOut) => void): void
+
+export declare function runtimeChangesCursorNext(handle: ExternalObject<ChangesCursorHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeChangesCursorTake(handle: ExternalObject<OperationHandle>): ExternalObject<ChangesCursorHandle>
+
+/** Parse canonical change-set bytes under a compiled schema. */
+export declare function runtimeChangesParse(handle: ExternalObject<RuntimeHandle>, schema: ExternalObject<SchemaHandle>, bytes: Uint8Array, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeChangesTake(handle: ExternalObject<OperationHandle>): ChangesOut
+
+export declare function runtimeClose(handle: ExternalObject<RuntimeHandle>, callback: (arg: CloseOut) => void): void
+
+export declare function runtimeCursorClose(handle: ExternalObject<CursorHandle>, callback: (arg: CloseOut) => void): void
+
+/** Publish the cursor's next page; a terminal store failure closes it. */
+export declare function runtimeCursorNext(handle: ExternalObject<CursorHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeCursorTake(handle: ExternalObject<OperationHandle>): ExternalObject<CursorHandle>
+
+/**
+ * Apply a sealed change set as one judged commit; with `expected`, only if
+ * the state that witness observed is still current.
+ */
+export declare function runtimeDbApply(db: ExternalObject<DbHandle>, changes: ExternalObject<ChangesHandle>, expected: ExternalObject<WitnessHandle> | undefined | null, callback: () => void): ExternalObject<OperationHandle>
+
+/** Drop the database's derived query caches. */
+export declare function runtimeDbClearCache(db: ExternalObject<DbHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeDbInspect(db: ExternalObject<DbHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeDbInspectTake(handle: ExternalObject<OperationHandle>): DbInspection
+
+/** Judge a sealed change set against the current state without committing. */
+export declare function runtimeDbJudge(db: ExternalObject<DbHandle>, changes: ExternalObject<ChangesHandle>, expected: ExternalObject<WitnessHandle> | undefined | null, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeDbSnapshot(db: ExternalObject<DbHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeDbTake(handle: ExternalObject<OperationHandle>): DbOpened
+
+/** Decode canonical-codec bytes holding only additions of `relation`. */
+export declare function runtimeDecodeRows(handle: ExternalObject<RuntimeHandle>, schema: ExternalObject<SchemaHandle>, relation: number, bytes: Uint8Array, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeDirectoryAcquire(handle: ExternalObject<RuntimeHandle>, path: string, callback: () => void): ExternalObject<OperationHandle>
+
+/**
+ * Hold the directory open across awaited JavaScript work; end it with
+ * `runtimeDirectoryEnd`.
+ */
+export declare function runtimeDirectoryBegin(handle: ExternalObject<DirectoryHandle>): ExternalObject<OperationHandle>
+
+export declare function runtimeDirectoryCheck(handle: ExternalObject<OperationHandle>): void
+
+export declare function runtimeDirectoryClose(handle: ExternalObject<DirectoryHandle>, remove: boolean, callback: (arg: CloseOut) => void): void
+
+/**
+ * Open (or create) one database in a child directory of an owned
+ * directory, under a compiled schema.
+ */
+export declare function runtimeDirectoryDbOpen(handle: ExternalObject<DirectoryHandle>, childName: string, schema: ExternalObject<SchemaHandle>, create: boolean, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeDirectoryEnd(handle: ExternalObject<OperationHandle>): void
+
+export declare function runtimeDirectoryTake(handle: ExternalObject<OperationHandle>): ExternalObject<DirectoryHandle>
+
+export declare function runtimeDraftClose(handle: ExternalObject<DraftHandle>, callback: (arg: CloseOut) => void): void
+
+/** Stage `rows` removals of `relation`, shaped like `runtimeDraftInsert`. */
+export declare function runtimeDraftDelete(handle: ExternalObject<DraftHandle>, relation: number, rows: bigint, cells: Array<CellValue>, callback: () => void): ExternalObject<OperationHandle>
+
+/** Seal the draft into an immutable change set; the draft is spent. */
+export declare function runtimeDraftFinish(handle: ExternalObject<DraftHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+/**
+ * Stage `rows` additions of `relation`; `cells` is row-major in sealed
+ * field order. A refused chunk spends the draft.
+ */
+export declare function runtimeDraftInsert(handle: ExternalObject<DraftHandle>, relation: number, rows: bigint, cells: Array<CellValue>, callback: () => void): ExternalObject<OperationHandle>
+
+/** Open a database-free change draft under a compiled schema. */
+export declare function runtimeDraftOpen(handle: ExternalObject<RuntimeHandle>, schema: ExternalObject<SchemaHandle>): ExternalObject<DraftHandle>
+
+/** Encode `rows` rows of `relation` into the canonical change-set row codec. */
+export declare function runtimeEncodeRows(handle: ExternalObject<RuntimeHandle>, schema: ExternalObject<SchemaHandle>, relation: number, rows: bigint, cells: Array<CellValue>, callback: () => void): ExternalObject<OperationHandle>
+
+/** Why a bridge call failed. Thrown to JavaScript as this `_tag` object. */
+export type RuntimeError =
+  | { _tag: 'RuntimeAlreadyLive' }
+  | { _tag: 'ForeignRuntime' }
+  | { _tag: 'ClosedHandle' }
+  | { _tag: 'HandleBusy' }
+  | { _tag: 'SpentHandle' }
+  | { _tag: 'QueueFull' }
+  | { _tag: 'InvalidArgument' }
+  | { _tag: 'InvalidValue'; message: string }
+  | { _tag: 'Internal' }
+  | { _tag: 'DirectoryBusy' }
+  | { _tag: 'WriterBusy' }
+  | { _tag: 'InvalidPath' }
+  | { _tag: 'Io'; kind: string; osCode?: number }
+  | { _tag: 'ResourceLimit'; dimension: string; used: bigint; requested: bigint; limit: bigint }
+  | { _tag: 'Engine'; kind: string; message: string }
+  | { _tag: 'Malformed'; path: string; message: string }
+  | { _tag: 'Cancelled' }
+  | { _tag: 'OutOfMemory' }
+
+export declare function runtimeInspect(handle: ExternalObject<RuntimeHandle>): InspectionOut
+
+export declare function runtimeJudgeTake(handle: ExternalObject<OperationHandle>): JudgeOutcome
+
+/**
+ * The one close authority: begin the database's drain and report its
+ * real outcome.
+ */
+export declare function runtimeManagedDbClose(db: ExternalObject<DbHandle>, callback: (arg: CloseOut) => void): void
+
+/** Start the one live runtime. `optionsJson` is a `RuntimeOptionsIn`. */
+export declare function runtimeOpen(optionsJson: string): ExternalObject<RuntimeHandle>
+
+export interface RuntimeOptionsIn {
+  workers?: number
+  queueCapacity?: number
+  cleanupCapacity?: number
+  ownerCapacity?: number
+  nativeHandleCapacity?: number
+  cleanupTimeoutMs?: number
+}
+
+/** One page of rows; `null` is the end of the cursor. */
+export declare function runtimePageTake(handle: ExternalObject<OperationHandle>): Array<Array<CellValue>> | null
+
+export declare function runtimePreparedClose(handle: ExternalObject<PreparedHandle>, callback: (arg: CloseOut) => void): void
+
+export declare function runtimePreparedExecute(handle: ExternalObject<PreparedHandle>, params: Array<ParamIn>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimePreparedReleaseMemory(handle: ExternalObject<PreparedHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+/**
+ * Adopt one compiled worker-owned plan. Dropping an untaken output closes
+ * the same resource; JavaScript is never its only cleanup authority.
+ */
+export declare function runtimePreparedTake(handle: ExternalObject<OperationHandle>): ExternalObject<PreparedHandle>
+
+/** One executor round trip with no payload. */
+export declare function runtimeReady(handle: ExternalObject<RuntimeHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeResultClose(handle: ExternalObject<ResultHandle>, callback: (arg: CloseOut) => void): void
+
+/** Collect every row of a sealed result; the result stays available. */
+export declare function runtimeResultCollect(handle: ExternalObject<ResultHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+/** Move a sealed result's backing into its one cursor. */
+export declare function runtimeResultCursor(handle: ExternalObject<ResultHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeResultTake(handle: ExternalObject<OperationHandle>): ExternalObject<ResultHandle>
+
+export declare function runtimeRowsTake(handle: ExternalObject<OperationHandle>): Array<Array<CellValue>>
+
+export declare function runtimeRowTake(handle: ExternalObject<OperationHandle>): Array<CellValue> | null
+
+export declare function runtimeSnapshotClose(handle: ExternalObject<SnapshotHandle>, callback: (arg: CloseOut) => void): void
+
+export declare function runtimeSnapshotExecute(handle: ExternalObject<SnapshotHandle>, query: ExternalObject<QueryHandle>, params: Array<ParamIn>, callback: () => void): ExternalObject<OperationHandle>
+
+/** Read one row by a key statement of `relation`. */
+export declare function runtimeSnapshotGet(handle: ExternalObject<SnapshotHandle>, relation: number, keyStatement: number, keyValues: Array<CellValue>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeSnapshotPrepare(handle: ExternalObject<SnapshotHandle>, query: ExternalObject<QueryHandle>, callback: () => void): ExternalObject<OperationHandle>
+
+export declare function runtimeSnapshotTake(handle: ExternalObject<OperationHandle>): SnapshotOpened
+
+/** The number of rows one draft chunk staged. */
+export declare function runtimeStagedTake(handle: ExternalObject<OperationHandle>): bigint
+
+/** Take a payload-less completion. */
+export declare function runtimeTake(handle: ExternalObject<OperationHandle>): void
+
+/** A scalar expression over rule-local variables. */
+export type ScalarExprIn =
+  | { kind: 'Var'; var: number }
+  | { kind: 'Literal'; value: ValueIn }
+  | { kind: 'Negate'; expr: ScalarExprIn }
+  | { kind: 'Add'; left: ScalarExprIn; right: ScalarExprIn }
+  | { kind: 'Subtract'; left: ScalarExprIn; right: ScalarExprIn }
+  | { kind: 'Multiply'; left: ScalarExprIn; right: ScalarExprIn }
+  | { kind: 'Divide'; left: ScalarExprIn; right: ScalarExprIn }
+  | { kind: 'MulDiv'; a: ScalarExprIn; b: ScalarExprIn; divisor: ScalarExprIn; rounding: RoundingIn }
+  | { kind: 'Measure'; expr: ScalarExprIn }
+  | { kind: 'Cast'; cast: NumericCastIn; expr: ScalarExprIn }
+  | { kind: 'IsNaN'; expr: ScalarExprIn }
+  | { kind: 'IsFinite'; expr: ScalarExprIn }
+
+/** TypeScript SDK declarations for a compiled schema. */
+export declare function schemaBindings(schema: ExternalObject<SchemaHandle>): SchemaBindings
+
+export type SchemaBindings =
+  | { _tag: 'Bindings'; source: string }
+  | { _tag: 'Unrepresentable'; coordinate: string; reason: string }
+
+export type SchemaCompiled =
+  | { _tag: 'Compiled'; schema: ExternalObject<SchemaHandle>; descriptor: SchemaDescriptorOut }
+  | { _tag: 'Invalid'; diagnostic: SchemaDiagnostic }
+  | { _tag: 'Malformed'; path: string; message: string }
+
+/**
+ * The sealed descriptor: relations with ids, field types and newtypes,
+ * materialized statements, and the hex schema fingerprint.
+ */
+export interface SchemaDescriptorOut {
+  relations: Array<RelationOut>
+  statements: Array<StatementOut>
+  fingerprint: string
+}
+
+/**
+ * Why a spec did not compile: unresolved names (`Spec`), or a resolved
+ * descriptor the engine refused (`Schema`, citing descriptor statement ids).
+ */
+export type SchemaDiagnostic =
+  | { _tag: 'Spec'; issues: Array<SpecIssueOut> }
+  | { _tag: 'Schema'; code: string; message: string; statement?: StatementCite; conflict?: StatementCite }
+
+export interface SchemaSpecIn {
+  relations: Array<RelationSpecIn>
+  statements: Array<StatementSpecIn>
+}
+
+export type SegmentOpIn = 'Intersection' | 'Difference'
+
+export interface SelectionIn {
+  field: string
+  set: LiteralSetSpecIn
+}
+
+export interface SelectionOut {
+  field: number
+  values: Array<CellValue>
+}
+
+export type SettledOut =
+  | { _tag: 'Opened'; pending: number }
+  | { _tag: 'Decided'; receipt: ReceiptOut }
+  | { _tag: 'Synced'; seq: bigint }
+  | { _tag: 'Resolved'; receipt?: ReceiptOut }
+  | { _tag: 'Frozen'; seq: bigint }
+  | { _tag: 'Migrated'; seq: bigint }
+  | { _tag: 'Refused'; refusal: RefusalOut }
+
+export interface SideOut {
+  relation: number
+  projection: Array<number>
+  selection: Array<SelectionOut>
+}
+
+/** One side of a containment or capacity statement, all by name. */
+export interface SideSpecIn {
+  relation: string
+  projection: Array<string>
+  selection: Array<SelectionIn>
+}
+
+/**
+ * A pinned snapshot, the witness of the state it observed, and that
+ * state's generation.
+ */
+export interface SnapshotOpened {
+  snapshot: ExternalObject<SnapshotHandle>
+  witness: ExternalObject<WitnessHandle>
+  generation: bigint
+}
+
+/**
+ * One spec resolution issue; `statement` indexes the spec's statements,
+ * `relation` and `row` its relations and a closed relation's rows.
+ */
+export interface SpecIssueOut {
+  code: string
+  message: string
+  statement?: number
+  relation?: number
+  row?: number
+}
+
+export interface StatementCite {
+  id: number
+  spelling: string
+}
+
+/** One materialized statement; `id` is its `StatementId`. */
+export type StatementOut =
+  | { _tag: 'Functionality'; id: number; spelling: string; relation: number; projection: Array<number> }
+  | { _tag: 'Containment'; id: number; spelling: string; source: SideOut; target: SideOut }
+  | { _tag: 'Capacity'; id: number; spelling: string; target: SideOut; weight: WeightOut; lo: bigint; hi: CeilingOut; source: SideOut }
+
+/** One dependency statement; `bidirectional` containment is the `==` form. */
+export type StatementSpecIn =
+  | { kind: 'Fd'; relation: string; projection: Array<string> }
+  | { kind: 'Containment'; source: SideSpecIn; target: SideSpecIn; bidirectional: boolean }
+  | { kind: 'Capacity'; target: SideSpecIn; weight: WeightSpecIn; window: CapacityWindowSpecIn; source: SideSpecIn }
+
+/** One step: requests to perform now, tickets settled by it, and the head. */
+export interface StepOut {
+  io: Array<IoRequestOut>
+  done: Array<DoneOut>
+  head?: HeadOut
+}
+
+export type TermIn =
+  | { kind: 'Var'; var: number }
+  | { kind: 'Param'; param: number }
+  | { kind: 'ParamSet'; param: number }
+  | { kind: 'Literal'; value: ValueIn }
+
+/** Validate one query IR (JSON) against a compiled schema. */
+export declare function validateQuery(schema: ExternalObject<SchemaHandle>, irJson: string): QueryValidated
+
+/** One literal value as spelled. Intervals are half-open and nonempty. */
+export type ValueIn =
+  | { kind: 'Bool'; value: boolean }
+  | { kind: 'U64'; value: string }
+  | { kind: 'I64'; value: string }
+  | { kind: 'F64'; value: string }
+  | { kind: 'String'; value: string }
+  | { kind: 'Uuid'; value: string }
+  | { kind: 'FixedBytes'; value: string }
+  | { kind: 'IntervalU64'; start: string; end: string }
+  | { kind: 'IntervalI64'; start: string; end: string }
+  | { kind: 'IntervalF64'; start: string; end: string }
+
+/** One structural field type. */
+export type ValueTypeIn =
+  | { kind: 'Bool' }
+  | { kind: 'U64' }
+  | { kind: 'I64' }
+  | { kind: 'F64' }
+  | { kind: 'String' }
+  | { kind: 'Uuid' }
+  | { kind: 'FixedBytes'; len: number }
+  | { kind: 'Interval'; element: IntervalElementIn }
+  | { kind: 'FixedInterval'; element: FixedIntervalElementIn; width: string }
+
+export type ValueTypeOut =
+  | { _tag: 'Bool' }
+  | { _tag: 'U64' }
+  | { _tag: 'I64' }
+  | { _tag: 'F64' }
+  | { _tag: 'String' }
+  | { _tag: 'Uuid' }
+  | { _tag: 'FixedBytes'; len: number }
+  | { _tag: 'Interval'; element: IntervalElementOut }
+  | { _tag: 'FixedInterval'; element: IntervalElementOut; width: bigint }
+
+/** One violated statement: its id, canonical spelling and the cited facts. */
+export type ViolationOut =
+  | { _tag: 'Functionality'; statement: number; spelling: string; facts: Array<FactOut> }
+  | { _tag: 'Containment'; statement: number; spelling: string; facts: Array<FactOut> }
+  | { _tag: 'Capacity'; statement: number; spelling: string; measure: bigint; facts: Array<FactOut> }
+
+export type WeightOut =
+  | { _tag: 'Unit' }
+  | { _tag: 'Field'; field: number }
+  | { _tag: 'Duration'; field: number }
+
+export type WeightSpecIn =
+  | { kind: 'Unit' }
+  | { kind: 'Field'; field: string }
+  | { kind: 'Duration'; field: string }