@korajs/core 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/sql-gen-ByOZIQU-.d.ts

@@ -0,0 +1,622 @@
+import { ai as TimeSource, H as HLCTimestamp, O as OperationInput, A as AtomicOp, a as Operation, M as MergeTrace, S as SchemaDefinition, C as CollectionDefinition, a5 as RelationDefinition } from './events-BSU-0z5O.js';
+
+/**
+ * Highest logical counter value that fits the 5-digit zero-padded slot in the
+ * serialized timestamp form. The serialized string must sort lexicographically
+ * in exactly the same order as {@link HybridLogicalClock.compare}; a 6-digit
+ * logical value would shift the padding and silently break that invariant for
+ * every stored `_version` column and operation timestamp. When the counter
+ * would exceed this cap, the clock carries into wallTime instead
+ * (wallTime + 1, logical = 0), which preserves both monotonicity and the
+ * serialized ordering.
+ */
+declare const MAX_LOGICAL = 99999;
+/**
+ * Hybrid Logical Clock implementation based on Kulkarni et al.
+ *
+ * Provides a total order that respects causality without requiring synchronized clocks.
+ * Each call to now() returns a timestamp strictly greater than the previous one.
+ *
+ * @example
+ * ```typescript
+ * const clock = new HybridLogicalClock('node-1')
+ * const ts1 = clock.now()
+ * const ts2 = clock.now()
+ * // HybridLogicalClock.compare(ts1, ts2) < 0 (ts1 is earlier)
+ * ```
+ */
+declare class HybridLogicalClock {
+    private readonly nodeId;
+    private readonly timeSource;
+    private readonly onDriftWarning?;
+    private readonly onDriftError?;
+    private wallTime;
+    private logical;
+    private referenceOffsetMs;
+    constructor(nodeId: string, timeSource?: TimeSource, onDriftWarning?: ((driftMs: number) => void) | undefined, onDriftError?: ((driftMs: number) => void) | undefined);
+    /**
+     * Records the known offset between an external time reference (usually the
+     * sync server, learned at handshake) and this device's physical clock:
+     * `referenceTime - localPhysicalTime`. Once set, drift evaluation and remote
+     * timestamp validation are performed against reference-corrected time, so a
+     * device with a wrong local clock still validates remote timestamps correctly.
+     */
+    setReferenceOffset(offsetMs: number): void;
+    getReferenceOffset(): number | null;
+    /** Physical time corrected by the known reference offset, when available. */
+    private effectiveTime;
+    /**
+     * Generate a new timestamp for a local event.
+     * Guarantees monotonicity: each call returns a timestamp strictly greater than the previous.
+     *
+     * Never throws and never blocks a local write: if the physical clock has
+     * fallen behind the HLC (e.g. the user corrected a fast clock), the HLC
+     * freezes wallTime and advances the logical counter, and drift is reported
+     * through the onDriftWarning / onDriftError callbacks instead.
+     */
+    now(): HLCTimestamp;
+    /**
+     * Update clock on receiving a remote timestamp.
+     * Merges the remote clock state with the local state to maintain causal ordering.
+     *
+     * @throws {InvalidTimestampError} If the remote timestamp has non-integer or
+     * negative wallTime/logical, or logical beyond {@link MAX_LOGICAL}. Checked
+     * BEFORE any state change, so malformed input cannot corrupt this clock.
+     * @throws {RemoteClockDriftError} If the remote timestamp is more than 5 minutes
+     * ahead of reference-corrected local time. Validation happens BEFORE any state
+     * is adopted, so a rejected timestamp cannot poison this clock. When no
+     * reference offset is known and this clock is uninitialized (cold start with
+     * a possibly-wrong local clock), validation is skipped, matching the previous
+     * cold-start behavior but now without a corrupting failure mode afterward.
+     */
+    receive(remote: HLCTimestamp): HLCTimestamp;
+    /**
+     * Advance this clock to at least the given timestamp.
+     *
+     * Used after a timestamp rebase rewrites unsynced operations: future `now()`
+     * timestamps must sort after every rebased operation, otherwise a write issued
+     * immediately after the rebase could interleave with (or precede) rebased ops
+     * and break the log's total order. Never moves the clock backward — a
+     * timestamp at or before the current state is a no-op, preserving the
+     * monotonicity guarantee of `now()`.
+     *
+     * Inputs with logical > MAX_LOGICAL are normalized deterministically by
+     * carrying the excess into wallTime, so the adopted state always leaves room
+     * for the next increment inside the serializable range.
+     */
+    advanceTo(ts: HLCTimestamp): void;
+    /**
+     * Carry the logical counter into wallTime when an increment pushed it past
+     * MAX_LOGICAL. Bumping wallTime by 1ms keeps the timestamp strictly greater
+     * than everything issued before (monotonicity) while keeping the logical
+     * counter inside the 5-digit slot the serialized form depends on.
+     */
+    private carryLogicalOverflow;
+    /**
+     * Compare two timestamps. Returns negative if a < b, positive if a > b, zero if equal.
+     * Total order: wallTime first, then logical, then nodeId (lexicographic).
+     */
+    static compare(a: HLCTimestamp, b: HLCTimestamp): number;
+    /**
+     * Serialize an HLC timestamp to a string that sorts lexicographically.
+     * Format: zero-padded wallTime:logical:nodeId
+     *
+     * @throws {InvalidTimestampError} If wallTime does not fit 15 digits or
+     * logical does not fit 5 digits (or either is negative/non-integer). Such a
+     * value would overflow its zero-padded slot and the serialized string would
+     * no longer sort in the same order as {@link HybridLogicalClock.compare} —
+     * silently corrupting every LWW comparison on stored `_version` columns.
+     * Internal clocks can no longer produce such values (the logical counter
+     * carries into wallTime); this guards against hand-built timestamps.
+     */
+    static serialize(ts: HLCTimestamp): string;
+    /**
+     * Deserialize an HLC timestamp from its serialized string form.
+     */
+    static deserialize(s: string): HLCTimestamp;
+    /**
+     * Reports drift between the HLC and (reference-corrected) physical time.
+     * Reporting only: local timestamp generation is never blocked, because the
+     * user's data always outranks the quality of its timestamps.
+     */
+    private checkDrift;
+}
+
+/**
+ * Content-hash versions for operation ids.
+ *
+ * - **1** (Kora <= beta.12): hashes type, collection, recordId,
+ *   data, timestamp, nodeId and atomicOps. previousData, sequenceNumber,
+ *   causalDeps and schemaVersion are NOT covered (CORE-1).
+ * - **2**: additionally hashes previousData, sequenceNumber, causalDeps (as a
+ *   set) and schemaVersion, with the version itself as a domain tag, and binary
+ *   values in their canonical tagged form. Operations carry `hashVersion: 2`.
+ */
+type OperationHashVersion = 1 | 2;
+/** Hash version new operations get: 2 since protocol v2 (beta.13). */
+declare const DEFAULT_OPERATION_HASH_VERSION: OperationHashVersion;
+/** The operation fields a content hash can cover. */
+interface HashableOperation {
+    nodeId: string;
+    type: OperationInput['type'];
+    collection: string;
+    recordId: string;
+    data: Record<string, unknown> | null;
+    previousData: Record<string, unknown> | null;
+    timestamp: HLCTimestamp;
+    sequenceNumber: number;
+    causalDeps: readonly string[];
+    schemaVersion: number;
+    atomicOps?: Record<string, AtomicOp>;
+}
+/**
+ * Compute the content-addressed ID for an operation using SHA-256.
+ * The same operation content always produces the same hash, ensuring deduplication.
+ *
+ * Two call forms:
+ * - `computeOperationId(input, serializedTimestamp)`: the version-1 hash (legacy
+ *   form, used by the store's rebase and node-id rotation).
+ * - `computeOperationId(op, version)`: the hash of the given version over a full
+ *   operation (with its HLC timestamp).
+ *
+ * @returns A hex-encoded SHA-256 hash
+ */
+declare function computeOperationId(input: OperationInput, timestamp: string): Promise<string>;
+declare function computeOperationId(op: HashableOperation, version: OperationHashVersion): Promise<string>;
+/**
+ * Deterministic JSON serialization with sorted keys.
+ * Ensures identical objects always produce identical strings regardless of property insertion order.
+ *
+ * @param obj - The value to serialize
+ * @returns A deterministic JSON string
+ */
+declare function canonicalize(obj: unknown): string;
+
+/** Options for {@link createOperation}. */
+interface CreateOperationOptions {
+    /**
+     * Content-hash version of the new operation's id. Defaults to 2 (protocol v2),
+     * which commits the id to every semantic field (CORE-1); 1 is the legacy hash.
+     */
+    hashVersion?: OperationHashVersion;
+}
+/**
+ * Creates an immutable, content-addressed Operation from the given parameters.
+ * The operation is deep-frozen after creation — it cannot be modified.
+ *
+ * @param input - The operation parameters (without id, which is computed)
+ * @param clock - The HLC clock to generate the timestamp
+ * @param options - Optional hash version (default 2)
+ * @returns A frozen Operation with a content-addressed id
+ *
+ * @example
+ * ```typescript
+ * const op = await createOperation({
+ *   nodeId: 'device-1',
+ *   type: 'insert',
+ *   collection: 'todos',
+ *   recordId: 'rec-1',
+ *   data: { title: 'Ship it' },
+ *   previousData: null,
+ *   sequenceNumber: 1,
+ *   causalDeps: [],
+ *   schemaVersion: 1,
+ * }, clock)
+ * ```
+ */
+declare function createOperation(rawInput: OperationInput, clock: HybridLogicalClock, options?: CreateOperationOptions): Promise<Operation>;
+/**
+ * Validates operation input parameters. Throws OperationError with
+ * contextual information on validation failure.
+ */
+declare function validateOperationParams(input: OperationInput): void;
+/**
+ * Verify an operation's id against its content, using the hash version the
+ * operation declares (`hashVersion`, absent = 1). A version-1 id does not cover
+ * previousData, sequenceNumber, causalDeps or schemaVersion (CORE-1), so only a
+ * version-2 operation is protected against rewriting those.
+ *
+ * Returns false for an unknown hash version.
+ *
+ * @param op - The operation to verify
+ * @returns true when `op.id` is the content hash of `op`
+ */
+declare function verifyOperationId(op: Operation): Promise<boolean>;
+/**
+ * Verify the integrity of an operation by recomputing its content hash.
+ * Returns true if the id matches the recomputed hash. Same as
+ * {@link verifyOperationId}.
+ */
+declare function verifyOperationIntegrity(op: Operation): Promise<boolean>;
+/**
+ * Type guard for Operation interface.
+ */
+declare function isValidOperation(value: unknown): value is Operation;
+
+/**
+ * Transforms operations created under an older schema version so they are valid
+ * after a schema upgrade. Used during sync when client and server schema versions differ
+ * but remain within the server's supported range.
+ */
+interface OperationTransform {
+    /** Schema version the operation was authored against */
+    readonly fromVersion: number;
+    /** Target schema version after transformation */
+    readonly toVersion: number;
+    /**
+     * Transform a single operation. Return `null` to drop operations that cannot be migrated.
+     */
+    transform(operation: Operation): Operation | null;
+}
+
+/**
+ * Version of the serialized fold-state format ({@link FoldState}). Bumped on any
+ * change to the on-disk shape. A reader that sees a different version must refuse
+ * the state and re-fold the record from its operation log.
+ */
+declare const FOLD_STATE_VERSION = 2;
+/**
+ * A write's position in the record's total order: the operation's HLC timestamp
+ * (serialized, so it compares as a plain string exactly like
+ * `HybridLogicalClock.compare`), then the operation id as a tie-breaker. Two
+ * distinct operations never share a stamp, even when a buggy or forged node reuses
+ * an HLC, so every "latest wins" comparison in the fold is a strict total order.
+ *
+ * A write to a `merge('server-authoritative')` field by an authoritative node
+ * ({@link FoldOptions.authoritativeNodeIds}) carries class `c: 1`, which orders
+ * before the HLC: the order is lexicographic on (class, HLC, op id).
+ */
+interface Stamp {
+    /** `HybridLogicalClock.serialize(timestamp)` of the writing operation (or field version). */
+    t: string;
+    /** Id of the writing operation. */
+    o: string;
+    /** Authority class (1 = authoritative write). Absent means 0. */
+    c?: 1;
+}
+/**
+ * One write in a field's embedded log ({@link RegisterFieldState},
+ * {@link ResolverFieldState}).
+ */
+interface FieldLogEntry {
+    /** Position of the write in the total order. */
+    s: Stamp;
+    /** The written value (for atomic writes, the author's resolved value). */
+    v: unknown;
+    /** Atomic intent, when the write was `op.increment()`, `op.max()`, ... */
+    a?: AtomicOp;
+    /** For resolver fields: the writer's base (`previousData[field]`), null for inserts. */
+    b?: unknown;
+    /**
+     * Resolver fields only: a snapshot entry ({@link createSnapshotState}). It resets
+     * the value without calling the resolver, and every older entry is pruned.
+     */
+    z?: 1;
+}
+/**
+ * Scalar fields (string, number, boolean, enum, timestamp, blob, secret, and any
+ * field declared `merge('lww')` or `merge('server-authoritative')`): a last-write-
+ * wins register generalized to the atomic-op chain.
+ *
+ * `e` holds the writes since (and including) the newest plain write, sorted by
+ * stamp. A plain write resets the field unconditionally, so everything older is
+ * irrelevant and is pruned. With no atomic writes `e` has exactly one entry: an
+ * LWW register. With atomic writes `e` is the chain the value is folded from (a
+ * same-type atomic chain composes; any other write takes its resolved value).
+ */
+interface RegisterFieldState {
+    k: 'reg';
+    e: FieldLogEntry[];
+    /** Cached `chainFold(e)`. Always equal to it; stored so materialization is O(1). */
+    val: unknown;
+}
+/** One element occurrence of an {@link ElementSetFieldState}. */
+interface ElementState {
+    /** The element value (canonical JSON parsed back, so key order is normalized). */
+    v: unknown;
+    /** Occurrence number: this is the n-th copy (from 0) of the value in the array. */
+    n: number;
+    /** Newest add. */
+    a: Stamp | null;
+    /** Oldest add plus the element's index in that write (its position in the array). */
+    f: {
+        s: Stamp;
+        i: number;
+    } | null;
+    /** Newest removal. */
+    r: Stamp | null;
+}
+/**
+ * Array fields: an LWW element set. Each element (identified by its canonical JSON)
+ * carries its newest add and newest removal; it is present iff its newest add is
+ * later than its newest removal and later than the newest write that replaced the
+ * whole array with a non-array (`clr`). Order is by first add.
+ */
+interface ElementSetFieldState {
+    k: 'set';
+    /** Append-only (`merge('append-only')`): removals are ignored. */
+    ao: boolean;
+    /** Whole-value shape register: is the field an array, or a non-array value (e.g. null)? */
+    sh: {
+        s: Stamp;
+        arr: boolean;
+        v?: unknown;
+    } | null;
+    /** Newest write that set the field to a non-array value: elements added before it are cleared. */
+    clr: Stamp | null;
+    /** Elements keyed by canonical JSON. */
+    el: Record<string, ElementState>;
+}
+/** One top-level key of a {@link KeyMapFieldState}. */
+interface KeyState {
+    s: Stamp;
+    /** true = removal marker. */
+    del: boolean;
+    v?: unknown;
+}
+/**
+ * Object and json fields: per-top-level-key LWW registers with removal markers.
+ * Nested values are whole-value LWW per top-level key. A write that replaces the
+ * whole value with a non-object (null, a scalar, a json array) is a shape write;
+ * keys written before the newest such write are cleared.
+ */
+interface KeyMapFieldState {
+    k: 'map';
+    sh: {
+        s: Stamp;
+        obj: boolean;
+        v?: unknown;
+    } | null;
+    clr: Stamp | null;
+    keys: Record<string, KeyState>;
+}
+/**
+ * `merge('counter')` fields: a base register (inserts and non-numeric writes) plus
+ * the deltas written after it. Value = base + sum of deltas in stamp order.
+ */
+interface CounterFieldState {
+    k: 'ctr';
+    base: {
+        s: Stamp;
+        v: unknown;
+    } | null;
+    /** Deltas written after `base`, sorted by stamp (older ones are pruned). */
+    d: Array<{
+        s: Stamp;
+        n: number;
+    }>;
+    /** Cached base + deltas, summed left to right in stamp order. */
+    val: unknown;
+}
+/** `merge('max')` / `merge('min')` fields: the extremum of every numeric write. */
+interface ExtremumFieldState {
+    k: 'max' | 'min';
+    best: {
+        s: Stamp;
+        v: number;
+    } | null;
+    /** LWW register over non-numeric writes, used only while no numeric write exists. */
+    reg: {
+        s: Stamp;
+        v: unknown;
+    } | null;
+}
+/**
+ * Fields with a custom resolver (tier 3): the full write log in stamp order and
+ * the value folded through the resolver (`local` = the merged value so far).
+ */
+interface ResolverFieldState {
+    k: 'res';
+    e: FieldLogEntry[];
+    val: unknown;
+    /** Message of the newest resolver exception (the fold fell back to LWW there), if any. */
+    err?: string;
+}
+/**
+ * Richtext fields: a set of opaque Yjs updates (base64) plus a reset register for
+ * plain-string (whole-value) writes. Updates written before the newest reset are
+ * hidden.
+ */
+interface RichtextFieldState {
+    k: 'rt';
+    reset: {
+        s: Stamp;
+        v: unknown;
+    } | null;
+    /** base64 Yjs update -> newest stamp that wrote it. */
+    u: Record<string, Stamp>;
+}
+/** Per-field merge state. Every variant is a state-based CRDT (join-semilattice). */
+type FieldState = RegisterFieldState | ElementSetFieldState | KeyMapFieldState | CounterFieldState | ExtremumFieldState | ResolverFieldState | RichtextFieldState;
+/** The kind tag of a {@link FieldState}. */
+type FoldFieldKind = FieldState['k'];
+/**
+ * The merge state of one record: the snapshot every replica (client store, server
+ * stores, backup restore, compaction) persists. It is a pure function of the set of
+ * operations merged into it, so two replicas holding the same operations hold an
+ * identical state, whatever order they arrived in.
+ *
+ * Serialized with {@link serializeFoldState}; see that function for the on-disk
+ * format.
+ */
+interface FoldState {
+    /** Format version, {@link FOLD_STATE_VERSION}. */
+    v: number;
+    /** Collection of the record. */
+    c: string;
+    /** Record id. */
+    r: string;
+    /** Oldest insert (the record's creation). null until an insert is merged. */
+    cr: Stamp | null;
+    /** Newest insert or update (any write keeps the record alive). */
+    w: Stamp | null;
+    /** Newest delete (the tombstone register). */
+    d: Stamp | null;
+    /** Newest operation of any type. */
+    u: Stamp | null;
+    /** Per-field states. */
+    f: Record<string, FieldState>;
+}
+/** Merges the opaque Yjs updates of a richtext field into one update. */
+type RichtextUpdateMerger = (updates: Uint8Array[]) => Uint8Array;
+/** True when update `a`'s content is contained in update `b`'s (a adds nothing to b). */
+type RichtextSubsumes = (a: Uint8Array, b: Uint8Array) => boolean;
+/** Which merge traces {@link mergeOp} emits. */
+type FoldTraceMode = 'conflicts' | 'all' | 'none';
+/** Options shared by the fold entry points. */
+interface FoldOptions {
+    /**
+     * Operations to leave out: the server terminally rejected them (or they are
+     * otherwise known never to have been stored). Ids, or a predicate.
+     */
+    exclude?: ReadonlySet<string> | ((op: Operation) => boolean);
+    /**
+     * Merges richtext Yjs updates. Required to materialize a richtext field with
+     * more than one live update (pass `mergeYjsUpdates` from `@korajs/store`).
+     * Core has no Yjs dependency, so it cannot supply one itself.
+     */
+    richtext?: RichtextUpdateMerger;
+    /**
+     * Optional richtext space bound: when given, an update whose content another
+     * update of the field contains, and whose stamp is not later, is dropped (it can
+     * never change a materialization). Devices persist a full Yjs snapshot per edit,
+     * so without it a field's state keeps every snapshot. Materializations are the
+     * same with or without it; every replica of one database must use the same setting
+     * for its serialized states to be byte-identical.
+     */
+    richtextSubsumes?: RichtextSubsumes;
+    /** Which traces to emit. Default `'conflicts'`. */
+    traces?: FoldTraceMode;
+    /**
+     * Additional node ids whose writes are authoritative for
+     * `merge('server-authoritative')` fields: legacy (randomly generated) server node
+     * ids the server keeps advertising at the handshake. Every node id in the reserved
+     * `kora:server:` namespace is authoritative without being listed. Authoritative
+     * writes beat every non-authoritative write of such a field regardless of HLC;
+     * within a class the later write wins. Every replica must fold with the same set.
+     */
+    authoritativeNodeIds?: ReadonlySet<string>;
+    /**
+     * Schema transforms applied at fold time (RT-84): an operation authored under another
+     * schema version is merged as `operationSchemaView(op, schema.version, transforms)`
+     * reads it. Stored operations are never rewritten. Transforms must be pure and
+     * deterministic, and every replica of a deployment must fold with the same ones (they
+     * are part of the fold plan fingerprint). Without transforms an operation folds as
+     * written.
+     */
+    transforms?: readonly OperationTransform[];
+}
+/**
+ * A per-field merge decision made by {@link mergeOp}. It carries every
+ * {@link MergeTrace} field except `operationA`: the fold state keeps only the id of
+ * the operation that produced the prior value (`priorOperationId`), so the caller,
+ * which owns the operation log, turns it into a `MergeTrace` with
+ * {@link toMergeTrace}.
+ */
+interface FoldTrace extends Omit<MergeTrace, 'operationA' | 'operationB'> {
+    /** The operation being merged (`MergeTrace.operationB`). */
+    operation: Operation;
+    /** Id of the operation that last wrote the field before this merge, or null. */
+    priorOperationId: string | null;
+    /**
+     * True when the incoming write was concurrent with the field's prior value (the
+     * writer's base differs from it, or the write lost to a newer one).
+     */
+    conflict: boolean;
+    /** Set when a custom resolver threw: the fold fell back to last-write-wins. */
+    error?: string;
+}
+/** The result of merging one operation. */
+interface MergeOpResult {
+    state: FoldState;
+    traces: FoldTrace[];
+    /** False when the operation changed nothing (a duplicate, an excluded op, a no-op write). */
+    changed: boolean;
+}
+/** The result of folding a set of operations from scratch. */
+interface FoldRecordResult {
+    /** null when no (non-excluded) operation was given. */
+    state: FoldState | null;
+    traces: FoldTrace[];
+}
+/** Per-field versions of a live record, the fold's equivalent of `_field_versions`. */
+interface FoldFieldVersions {
+    /** Field name -> HLC of the newest write that affected the field. */
+    fields: Record<string, HLCTimestamp>;
+    /** HLC of the record's creation (oldest insert). */
+    created: HLCTimestamp;
+    /** HLC of the newest operation of any type. */
+    latest: HLCTimestamp;
+}
+
+/**
+ * Generate CREATE TABLE and CREATE INDEX SQL for a single collection.
+ *
+ * @param collectionName - The collection name
+ * @param collection - The collection definition
+ * @param relations - Optional relations for FK references
+ * @returns An array of SQL statements (CREATE TABLE + CREATE INDEX)
+ */
+declare function generateSQL(collectionName: string, collection: CollectionDefinition, relations?: Record<string, RelationDefinition>): string[];
+/**
+ * Name of the index on `field` of `collection`.
+ *
+ * The collection name's length is part of the name, so two (collection, field)
+ * pairs can never produce the same index name. The previous scheme,
+ * `idx_<collection>_<field>`, gave `a_b`.`c` and `a`.`b_c` the same name, and the
+ * second `CREATE INDEX IF NOT EXISTS` silently did nothing (STORE-15).
+ *
+ * @param collection - Collection (table) name
+ * @param field - Indexed field (column) name
+ * @returns A collision-free index name
+ */
+declare function collectionIndexName(collection: string, field: string): string;
+/**
+ * Name the pre-beta.13 scheme gave the index on `field` of `collection`. Only
+ * used to find and drop those indexes once their replacements exist.
+ */
+declare function legacyCollectionIndexName(collection: string, field: string): string;
+/**
+ * Prefix of the `generateFullDDL` statement `--kora:schema-ceiling <version>` (RT-109).
+ * It is a SQL comment, so executing it does nothing; Kora's storage adapters read the
+ * database's stored schema version there and refuse to run the rest of the DDL against a
+ * database a newer build already migrated.
+ */
+declare const SCHEMA_CEILING_DIRECTIVE = "--kora:schema-ceiling";
+/**
+ * Generate the full DDL for all collections plus metadata tables.
+ *
+ * @param schema - The complete schema definition
+ * @returns An array of all SQL statements needed to initialize the database
+ */
+declare function generateFullDDL(schema: SchemaDefinition): string[];
+/**
+ * Render a string as a SQL string literal, doubling embedded single quotes
+ * (SEC-9b). Valid in SQLite and in Postgres with standard_conforming_strings
+ * (the default since 9.1), where a backslash is an ordinary character.
+ *
+ * @param value - The string to quote
+ * @returns The quoted literal, e.g. `'don''t know'`
+ */
+declare function sqlStringLiteral(value: string): string;
+/**
+ * Render a schema default value as a SQL literal for a `DEFAULT` clause. Strings
+ * and JSON-serialized arrays/objects are quoted with `sqlStringLiteral`, so a
+ * default containing a quote yields valid DDL instead of breaking it (SEC-9b).
+ *
+ * @param value - The field's default value
+ * @returns A SQL literal
+ */
+declare function sqlDefaultLiteral(value: unknown): string;
+/**
+ * Render the `CHECK (col IN (...))` constraint of an enum field, each value
+ * quoted with `sqlStringLiteral` (SEC-9b). No longer emitted by Kora's DDL (RT-101:
+ * enum membership is enforced by validation only); kept for tooling and tests.
+ *
+ * @param fieldName - The enum column
+ * @param values - The enum's allowed values
+ * @returns The CHECK clause
+ */
+declare function enumCheckConstraint(fieldName: string, values: readonly string[]): string;
+
+export { verifyOperationIntegrity as A, SCHEMA_CEILING_DIRECTIVE as B, type CounterFieldState as C, DEFAULT_OPERATION_HASH_VERSION as D, type ElementSetFieldState as E, type FoldState as F, canonicalize as G, type HashableOperation as H, collectionIndexName as I, enumCheckConstraint as J, type KeyMapFieldState as K, legacyCollectionIndexName as L, type MergeOpResult as M, sqlDefaultLiteral as N, type OperationTransform as O, sqlStringLiteral as P, validateOperationParams as Q, type RegisterFieldState as R, type Stamp as S, type FoldOptions as a, type FoldRecordResult as b, type FoldFieldVersions as c, type FoldTrace as d, type CreateOperationOptions as e, type ElementState as f, type ExtremumFieldState as g, FOLD_STATE_VERSION as h, type FieldLogEntry as i, type FieldState as j, type FoldFieldKind as k, type FoldTraceMode as l, HybridLogicalClock as m, type KeyState as n, MAX_LOGICAL as o, type OperationHashVersion as p, type ResolverFieldState as q, type RichtextFieldState as r, type RichtextSubsumes as s, type RichtextUpdateMerger as t, computeOperationId as u, createOperation as v, generateFullDDL as w, generateSQL as x, isValidOperation as y, verifyOperationId as z };