@nylorun/runtime 0.14.0-beta → 0.15.0-beta

package/dist/store/postgres/migrations/shared/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * Forward-only migrations of the shared `nylorun_streams` schema (Durable Streams §6): the
- * record of every Tenant's session events, the log heads, the relay's state and the
- * publication the stream relay reads. Unlike Tenant schemas, there is one for the database;
- * the Host migrates it at startup, before any Tenant opens, under an advisory lock.
- *
- * Adding a migration: append to `STREAMS_MIGRATIONS` with the next version. Never edit or
- * reorder an applied one.
- */
-import type { Sql } from "postgres";
-import { type Migration } from "../index.js";
-export declare const STREAMS_SCHEMA = "nylorun_streams";
-/** The publication the stream relay subscribes to. */
-export declare const STREAMS_PUBLICATION = "nylorun_stream_relay";
-export declare const STREAMS_MIGRATIONS: readonly Migration[];
-/** The shared schema version this Runtime writes and expects. */
-export declare const STREAMS_SCHEMA_VERSION: number;
-/**
- * Creates `nylorun_streams` when missing and applies every missing migration, in one
- * transaction under the schema's migration lock. Throws when the schema is newer than this
- * Runtime.
- */
-export declare function migrateStreamsSchema(sql: Sql, migrations?: readonly Migration[]): Promise<{
-    from: number;
-    to: number;
-}>;
-/**
- * Throws, naming the setting, when Postgres cannot run the stream relay: logical decoding
- * needs `wal_level = logical` (a restart) and a role allowed to replicate.
- */
-export declare function assertLogicalReplication(sql: Sql): Promise<void>;

package/dist/store/postgres/migrations/shared/index.js

@@ -1,92 +0,0 @@
-import { assertMigrations, lockSchema } from "../index.js";
-export const STREAMS_SCHEMA = "nylorun_streams";
-/** The publication the stream relay subscribes to. */
-export const STREAMS_PUBLICATION = "nylorun_stream_relay";
-export const STREAMS_MIGRATIONS = [
-    {
-        version: 1,
-        name: "record",
-        up: (s) => `
-      CREATE TABLE ${s}.session_log_heads (
-        tenant_id text COLLATE "C" NOT NULL,
-        session_id text COLLATE "C" NOT NULL,
-        -- The basin generation the session's events go to.
-        generation integer NOT NULL,
-        -- The next seq.
-        head bigint NOT NULL DEFAULT 0,
-        PRIMARY KEY (tenant_id, session_id)
-      );
-      CREATE TABLE ${s}.session_events (
-        tenant_id text COLLATE "C" NOT NULL,
-        session_id text COLLATE "C" NOT NULL,
-        seq bigint NOT NULL,
-        generation integer NOT NULL,
-        type text NOT NULL,
-        -- The nylorun.event/2 envelope, as written.
-        body json NOT NULL,
-        committed_at timestamptz NOT NULL DEFAULT now(),
-        PRIMARY KEY (tenant_id, session_id, seq)
-      );
-      -- One row per replication slot: whether the record still has to be reconciled with S2
-      -- after the slot was created (a crash during reconciliation leaves it pending).
-      CREATE TABLE ${s}.relay_slots (
-        slot_name text PRIMARY KEY,
-        reconcile_pending boolean NOT NULL
-      );
-      CREATE PUBLICATION ${STREAMS_PUBLICATION}
-        FOR TABLE ${s}.session_events WITH (publish = 'insert');
-    `,
-    },
-];
-/** The shared schema version this Runtime writes and expects. */
-export const STREAMS_SCHEMA_VERSION = STREAMS_MIGRATIONS.at(-1).version;
-/**
- * Creates `nylorun_streams` when missing and applies every missing migration, in one
- * transaction under the schema's migration lock. Throws when the schema is newer than this
- * Runtime.
- */
-export async function migrateStreamsSchema(sql, migrations = STREAMS_MIGRATIONS) {
-    assertMigrations(migrations);
-    const result = await sql.begin(async (tx) => {
-        await lockSchema(tx, STREAMS_SCHEMA);
-        return { result: await migrateInTx(tx, migrations) };
-    });
-    return result.result;
-}
-async function migrateInTx(tx, migrations) {
-    const s = STREAMS_SCHEMA;
-    await tx.unsafe(`
-    CREATE SCHEMA IF NOT EXISTS ${s};
-    CREATE TABLE IF NOT EXISTS ${s}.schema_version (
-      version integer PRIMARY KEY,
-      name text NOT NULL,
-      applied_at timestamptz NOT NULL DEFAULT now()
-    );`);
-    const [row] = await tx `
-    SELECT max(version)::int AS version FROM ${tx(`${s}.schema_version`)}`;
-    const from = row?.version ?? 0;
-    const latest = migrations.length;
-    if (from > latest)
-        throw new Error(`The ${s} schema is at version ${from}, newer than this Runtime's ${latest}: upgrade the Runtime`);
-    for (const migration of migrations.slice(from)) {
-        await tx.unsafe(migration.up(s));
-        await tx `INSERT INTO ${tx(`${s}.schema_version`)} (version, name)
-             VALUES (${migration.version}, ${migration.name})`;
-    }
-    return { from, to: latest };
-}
-/**
- * Throws, naming the setting, when Postgres cannot run the stream relay: logical decoding
- * needs `wal_level = logical` (a restart) and a role allowed to replicate.
- */
-export async function assertLogicalReplication(sql) {
-    const [row] = await sql `
-    SELECT current_setting('wal_level') AS wal_level,
-           (SELECT rolreplication OR rolsuper FROM pg_roles WHERE rolname = current_user) AS replicates`;
-    if (row?.wal_level !== "logical")
-        throw new Error(`Postgres has wal_level = ${row?.wal_level ?? "unknown"}; the stream relay needs logical replication. ` +
-            "Set wal_level = logical and restart Postgres (`nylorun start` does this for the local stack; " +
-            "on a managed Postgres, turn on its logical replication option). See DEPLOYMENT.md.");
-    if (!row.replicates)
-        throw new Error("The Runtime's Postgres role cannot replicate: grant it REPLICATION (ALTER ROLE … REPLICATION). See DEPLOYMENT.md.");
-}

package/dist/store/postgres/names.d.ts

@@ -1,11 +0,0 @@
-export declare const TENANT_SCHEMA_PREFIX = "tenant_";
-/** Postgres truncates identifiers longer than NAMEDATALEN - 1 bytes. */
-export declare const MAX_IDENTIFIER_BYTES = 63;
-/** The schema holding `tenantId`'s Session Store. Throws on an invalid id. */
-export declare function tenantSchemaName(tenantId: string): string;
-/** The Tenant id a schema name encodes, or undefined when it is not a Tenant schema. */
-export declare function tenantIdFromSchema(schema: string): string | undefined;
-/** Rejects names Postgres would truncate or that could not be quoted safely. */
-export declare function assertIdentifier(name: string): void;
-/** `"name"`, for SQL text built outside a tagged template (migrations). */
-export declare function quoteIdentifier(name: string): string;

package/dist/store/postgres/names.js

@@ -1,42 +0,0 @@
-/**
- * Tenant id ↔ Postgres schema name (architecture §8.1, §12.2).
- *
- * A Tenant's Session Store is the schema `"tenant_<id>"`, for example
- * `tn_01k8z3…` ↦ `"tenant_tn_01k8z3…"`. Tenant ids match
- * `^tn_[0-9a-hjkmnp-tv-z]{26}$` (lowercase ASCII), so the name is 36 bytes,
- * under Postgres' 63-byte identifier limit, and needs no case folding. It is
- * always written quoted. The mapping is total and reversible: a schema that
- * starts with `tenant_` but does not decode to a valid Tenant id is not a
- * Tenant.
- */
-import { isTenantId } from "@nylorun/core/compatibility";
-export const TENANT_SCHEMA_PREFIX = "tenant_";
-/** Postgres truncates identifiers longer than NAMEDATALEN - 1 bytes. */
-export const MAX_IDENTIFIER_BYTES = 63;
-/** The schema holding `tenantId`'s Session Store. Throws on an invalid id. */
-export function tenantSchemaName(tenantId) {
-    if (!isTenantId(tenantId))
-        throw new Error(`Invalid tenant id: ${tenantId}`);
-    const schema = `${TENANT_SCHEMA_PREFIX}${tenantId}`;
-    assertIdentifier(schema);
-    return schema;
-}
-/** The Tenant id a schema name encodes, or undefined when it is not a Tenant schema. */
-export function tenantIdFromSchema(schema) {
-    if (!schema.startsWith(TENANT_SCHEMA_PREFIX))
-        return undefined;
-    const id = schema.slice(TENANT_SCHEMA_PREFIX.length);
-    return isTenantId(id) ? id : undefined;
-}
-/** Rejects names Postgres would truncate or that could not be quoted safely. */
-export function assertIdentifier(name) {
-    if (name.length === 0 ||
-        Buffer.byteLength(name, "utf8") > MAX_IDENTIFIER_BYTES ||
-        !/^[a-z_][a-z0-9_]*$/.test(name))
-        throw new Error(`Invalid Postgres identifier: ${name}`);
-}
-/** `"name"`, for SQL text built outside a tagged template (migrations). */
-export function quoteIdentifier(name) {
-    assertIdentifier(name);
-    return `"${name}"`;
-}

package/dist/store/postgres/tenants.d.ts

@@ -1,90 +0,0 @@
-/**
- * The Tenant catalog on one Postgres database (architecture §8.2).
- *
- * A Tenant exists when its schema `"tenant_<id>"` exists (see `names.ts`); the
- * Host keeps no other registry. The envelope is the one row of the schema's
- * `tenant` table, and its `schemaVersion` is the schema's migrated version.
- *
- * - `createTenant` runs in one transaction: create the schema, migrate it,
- *   write the envelope and the bootstrap principals. A crash leaves nothing.
- *   Creating an existing Tenant with the same bootstrap principals returns
- *   `exists`; with different ones it throws `TenantConflictError`.
- * - `openTenant` migrates an older schema forward and returns its store. A
- *   schema newer than this Runtime, a failed migration or an unreadable
- *   envelope quarantines that Tenant only. A lost connection or an unavailable
- *   server says nothing about the Tenant, so it is thrown, never a quarantine.
- * - `deleteTenant` drops the schema with everything in it.
- *
- * Create, migrate and delete of one schema are serialized by a
- * transaction-level advisory lock on the schema name.
- */
-import type { Sql } from "postgres";
-import { type TenantEnvelope } from "@nylorun/core/contracts";
-import type { BootstrapPrincipal, Quarantine } from "../../tenant/types.js";
-import type { SessionStore } from "../types.js";
-import { type Migration } from "./migrations/index.js";
-export interface PostgresTenantCatalogOptions {
-    /** The shared pool. The catalog and its stores never end it. */
-    sql: Sql;
-    /** Clock for principal `createdAt`. Defaults to `() => new Date()`. */
-    now?: () => Date;
-    /** Passed to every opened store. */
-    onError?: (error: unknown) => void;
-    /** Tests only: the migrations this Runtime knows. */
-    migrations?: readonly Migration[];
-}
-export interface TenantListing {
-    id: string;
-    /** Null when the envelope cannot be read; `quarantine` says why. */
-    envelope: TenantEnvelope | null;
-    quarantine?: Quarantine;
-}
-export type CreateTenantResult = {
-    status: "created";
-    envelope: TenantEnvelope;
-} | {
-    status: "exists";
-    envelope: TenantEnvelope;
-};
-export type OpenTenantResult = {
-    status: "ok";
-    store: SessionStore;
-    envelope: TenantEnvelope;
-    migrated: {
-        from: number;
-        to: number;
-    };
-} | {
-    status: "quarantined";
-    reason: Quarantine;
-} | {
-    status: "not-found";
-};
-export interface PostgresTenantCatalog {
-    /** Every `tenant_*` schema that encodes a Tenant id, ordered by id. */
-    listTenants(): Promise<TenantListing[]>;
-    /** The ids of `listTenants`, without reading any envelope. */
-    listTenantIds(): Promise<string[]>;
-    /** Whether the Tenant's schema exists. */
-    tenantExists(id: string): Promise<boolean>;
-    /** Throws a `QuarantineError` (`envelope-invalid`) when unreadable. */
-    readEnvelope(id: string): Promise<TenantEnvelope>;
-    createTenant(input: {
-        envelope: TenantEnvelope;
-        principals: BootstrapPrincipal;
-    }): Promise<CreateTenantResult>;
-    /** Whether the stored bootstrap (and Studio) principals equal `bootstrap`. */
-    bootstrapMatches(id: string, bootstrap: BootstrapPrincipal): Promise<boolean>;
-    openTenant(id: string, options?: {
-        now?: () => Date;
-        onError?: (error: unknown) => void;
-    }): Promise<OpenTenantResult>;
-    /** Migrates an existing Tenant schema. Throws `schema-too-new` or the migration error. */
-    migrateTenant(id: string): Promise<{
-        from: number;
-        to: number;
-    }>;
-    /** Drops the schema and everything in it. Returns false when it did not exist. */
-    deleteTenant(id: string): Promise<boolean>;
-}
-export declare function createPostgresTenantCatalog(options: PostgresTenantCatalogOptions): PostgresTenantCatalog;

package/dist/store/postgres/tenants.js

@@ -1,228 +0,0 @@
-import { isTenantId } from "@nylorun/core/compatibility";
-import { TenantEnvelopeSchema, } from "@nylorun/core/contracts";
-import { STUDIO_PRINCIPAL_ID } from "../../tenant/principals.js";
-import { TenantConflictError, asQuarantine, quarantine, } from "../../tenant/quarantine.js";
-import { MIGRATIONS, lockSchema, migrateSchemaInTx, readSchemaVersion, schemaExists, } from "./migrations/index.js";
-import { TENANT_SCHEMA_PREFIX, tenantIdFromSchema, tenantSchemaName } from "./names.js";
-import { createPostgresSessionStore } from "./store.js";
-import { STREAMS_SCHEMA, migrateStreamsSchema } from "./migrations/shared/index.js";
-/**
- * Whether Postgres rejected a statement (a SQLSTATE), rather than the connection or the
- * server failing (classes 08, 53, 57, and the driver's own connection errors). Only the
- * first says something about the Tenant's schema.
- */
-function isStatementError(error) {
-    const code = error?.code;
-    return (typeof code === "string" &&
-        /^[0-9A-Z]{5}$/.test(code) &&
-        !/^(08|53|57)/.test(code));
-}
-export function createPostgresTenantCatalog(options) {
-    const { sql } = options;
-    const now = options.now ?? (() => new Date());
-    // The shared record (`nylorun_streams`) exists before any Tenant is created or opened.
-    let streamsReady;
-    const ensureStreams = () => (streamsReady ??= migrateStreamsSchema(sql).catch((error) => {
-        streamsReady = undefined;
-        throw error;
-    }));
-    const migrations = options.migrations ?? MIGRATIONS;
-    const latest = migrations.length;
-    async function readEnvelopeWith(q, id) {
-        const schema = tenantSchemaName(id);
-        const invalid = (message) => quarantine("envelope-invalid", message, { tenantId: id });
-        let rows;
-        try {
-            rows = await q `
-        SELECT id, name, created_at, updated_at, schema_version
-        FROM ${q(`${schema}.tenant`)}`;
-        }
-        catch (error) {
-            // A missing schema or `tenant` table is the Tenant's problem; anything else
-            // (a lost connection) is not, and is thrown as it is.
-            const code = error.code;
-            if (code !== "42P01" && code !== "3F000")
-                throw error;
-            throw invalid(`Tenant envelope could not be read: ${error.message}`);
-        }
-        if (rows.length !== 1)
-            throw invalid("Tenant envelope is missing");
-        const row = rows[0];
-        const parsed = TenantEnvelopeSchema.safeParse({
-            id: row.id,
-            name: row.name,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-            schemaVersion: row.schema_version,
-        });
-        if (!parsed.success)
-            throw invalid("Tenant envelope is not valid");
-        if (parsed.data.id !== id)
-            throw invalid(`Tenant envelope id ${parsed.data.id} does not match schema ${schema}`);
-        return parsed.data;
-    }
-    async function bootstrapMatchesWith(q, id, bootstrap) {
-        const schema = tenantSchemaName(id);
-        const rows = await q `
-      SELECT id, token_hash, idempotency_key FROM ${q(`${schema}.principals`)}
-      WHERE role = 'application'`;
-        const app = rows.find((row) => row.id === bootstrap.principalId);
-        if (!app ||
-            app.token_hash !== bootstrap.credentialHash ||
-            app.idempotency_key !== bootstrap.idempotencyKey)
-            return false;
-        const studio = rows.find((row) => row.id === STUDIO_PRINCIPAL_ID);
-        if (studio?.token_hash !== bootstrap.studioCredentialHash)
-            return false;
-        return (bootstrap.derivedPrincipals ?? []).every((principal) => rows.find((row) => row.id === principal.id)?.token_hash ===
-            principal.credentialHash);
-    }
-    const catalog = {
-        async listTenantIds() {
-            const schemas = await sql `
-        SELECT nspname FROM pg_namespace
-        WHERE starts_with(nspname, ${TENANT_SCHEMA_PREFIX})
-        ORDER BY nspname COLLATE "C"`;
-            return schemas.flatMap(({ nspname }) => tenantIdFromSchema(nspname) ?? []);
-        },
-        async tenantExists(id) {
-            return isTenantId(id) && schemaExists(sql, tenantSchemaName(id));
-        },
-        async listTenants() {
-            const listings = [];
-            for (const id of await catalog.listTenantIds()) {
-                try {
-                    listings.push({ id, envelope: await readEnvelopeWith(sql, id) });
-                }
-                catch (error) {
-                    listings.push({
-                        id,
-                        envelope: null,
-                        quarantine: asQuarantine(error) ??
-                            quarantine("open-failed", "Tenant schema could not be read", {
-                                tenantId: id,
-                            }).toQuarantine(),
-                    });
-                }
-            }
-            return listings;
-        },
-        readEnvelope(id) {
-            return readEnvelopeWith(sql, id);
-        },
-        async createTenant({ envelope, principals }) {
-            await ensureStreams();
-            const input = TenantEnvelopeSchema.parse(envelope);
-            const schema = tenantSchemaName(input.id);
-            const outcome = await sql.begin(async (tx) => {
-                await lockSchema(tx, schema);
-                if (await schemaExists(tx, schema))
-                    return { created: false };
-                await migrateSchemaInTx(tx, schema, migrations);
-                const stored = { ...input, schemaVersion: latest };
-                await tx `
-          INSERT INTO ${tx(`${schema}.tenant`)} (id, name, created_at, updated_at, schema_version)
-          VALUES (${stored.id}, ${stored.name}, ${stored.createdAt}, ${stored.updatedAt}, ${stored.schemaVersion})`;
-                const createdAt = now().toISOString();
-                await tx `
-          INSERT INTO ${tx(`${schema}.principals`)} (id, role, token_hash, idempotency_key, created_at)
-          VALUES (${principals.principalId}, 'application', ${principals.credentialHash},
-                  ${principals.idempotencyKey}, ${createdAt})`;
-                if (principals.studioCredentialHash)
-                    await tx `
-            INSERT INTO ${tx(`${schema}.principals`)} (id, role, token_hash, idempotency_key, created_at)
-            VALUES (${STUDIO_PRINCIPAL_ID}, 'application', ${principals.studioCredentialHash},
-                    NULL, ${createdAt})`;
-                for (const derived of principals.derivedPrincipals ?? [])
-                    await tx `
-            INSERT INTO ${tx(`${schema}.principals`)} (id, role, token_hash, idempotency_key, created_at)
-            VALUES (${derived.id}, 'application', ${derived.credentialHash}, NULL, ${createdAt})`;
-                return { created: true, envelope: stored };
-            });
-            if (outcome.created)
-                return { status: "created", envelope: outcome.envelope };
-            if (!(await bootstrapMatchesWith(sql, input.id, principals)))
-                throw new TenantConflictError();
-            return { status: "exists", envelope: await readEnvelopeWith(sql, input.id) };
-        },
-        async bootstrapMatches(id, bootstrap) {
-            if (!(await schemaExists(sql, tenantSchemaName(id))))
-                return false;
-            return bootstrapMatchesWith(sql, id, bootstrap);
-        },
-        async openTenant(id, storeOptions = {}) {
-            if (!isTenantId(id))
-                return { status: "not-found" };
-            await ensureStreams();
-            const schema = tenantSchemaName(id);
-            const version = await readSchemaVersion(sql, schema);
-            if (version === undefined)
-                return { status: "not-found" };
-            if (version > latest)
-                return {
-                    status: "quarantined",
-                    reason: quarantine("schema-too-new", `Tenant schema version ${version} is newer than this Runtime's ${latest}`, { tenantId: id }).toQuarantine(),
-                };
-            let migrated = { from: version, to: version };
-            if (version < latest) {
-                try {
-                    migrated = await catalog.migrateTenant(id);
-                }
-                catch (error) {
-                    if (!asQuarantine(error) && !isStatementError(error))
-                        throw error;
-                    return {
-                        status: "quarantined",
-                        reason: asQuarantine(error) ??
-                            quarantine("migration-failed", `Tenant schema migration from version ${version} failed: ${error.message}`, { tenantId: id }).toQuarantine(),
-                    };
-                }
-            }
-            let envelope;
-            try {
-                envelope = await readEnvelopeWith(sql, id);
-            }
-            catch (error) {
-                const reason = asQuarantine(error);
-                if (!reason)
-                    throw error;
-                return { status: "quarantined", reason };
-            }
-            const store = createPostgresSessionStore({
-                sql,
-                tenantId: id,
-                schema,
-                schemaVersion: latest,
-                now: storeOptions.now,
-                onError: storeOptions.onError ?? options.onError,
-            });
-            return { status: "ok", store, envelope, migrated };
-        },
-        async migrateTenant(id) {
-            const schema = tenantSchemaName(id);
-            const result = await sql.begin(async (tx) => {
-                await lockSchema(tx, schema);
-                if (!(await schemaExists(tx, schema)))
-                    throw new Error(`Tenant ${id} does not exist`);
-                return { result: await migrateSchemaInTx(tx, schema, migrations) };
-            });
-            return result.result;
-        },
-        async deleteTenant(id) {
-            const schema = tenantSchemaName(id);
-            return sql.begin(async (tx) => {
-                await lockSchema(tx, schema);
-                if (!(await schemaExists(tx, schema)))
-                    return false;
-                await tx `DROP SCHEMA ${tx(schema)} CASCADE`;
-                // The Tenant's share of the record goes with it (Durable Streams §15).
-                if ((await schemaExists(tx, STREAMS_SCHEMA))) {
-                    await tx `DELETE FROM ${tx(`${STREAMS_SCHEMA}.session_events`)} WHERE tenant_id = ${id}`;
-                    await tx `DELETE FROM ${tx(`${STREAMS_SCHEMA}.session_log_heads`)} WHERE tenant_id = ${id}`;
-                }
-                return true;
-            });
-        },
-    };
-    return catalog;
-}

package/dist/streams/relay/memory.d.ts

@@ -1,69 +0,0 @@
-/**
- * An in-memory record with a change source that behaves like a logical replication slot:
- * committed transactions are kept until acknowledged and replayed to the next reader, one
- * reader holds the slot at a time, and a dropped slot starts fresh. For unit tests and the
- * in-memory Session Store. Not durable.
- */
-import type { ChangeHandlers, ChangeSource, CommittedTx, LogHead, RecordReader, RecordRow } from "./types.js";
-export declare class MemoryRecord implements RecordReader {
-    /** `tenantId\0sessionId` → rows by seq. */
-    private readonly rows;
-    private readonly generations;
-    /** Committed transactions since the slot's confirmed position. */
-    private retained;
-    private lsn;
-    private slot;
-    private reader;
-    /** Commits rows as one transaction (the record is written by the Session Store). */
-    commit(rows: readonly RecordRow[]): void;
-    /** Sets a Tenant's basin generation (a reset moves it on). */
-    setGeneration(tenantId: string, generation: number): void;
-    /** Deletes a Tenant's rows, or one session's, as a reset or deletion does. */
-    deleteRows(tenantId: string, sessionId?: string): void;
-    /** Forgets a Tenant (deletion). */
-    deleteTenant(tenantId: string): void;
-    /** Drops the slot, as `max_slot_wal_keep_size` or an operator would. */
-    dropSlot(): void;
-    /** Ends the reader's connection but keeps the slot, as a network failure would. */
-    disconnect(): void;
-    /** A change source over this record; one at a time holds the slot. */
-    source(): ChangeSource;
-    readRange(tenantId: string, sessionId: string, from: number, to: number): Promise<RecordRow[]>;
-    heads(after: {
-        tenantId: string;
-        sessionId: string;
-    } | undefined, limit: number): Promise<LogHead[]>;
-    generation(tenantId: string): Promise<number | undefined>;
-    /** @internal */
-    attach(reader: MemoryChangeSource): {
-        fresh: boolean;
-        replay: CommittedTx[];
-    } | undefined;
-    /** @internal */
-    detach(reader: MemoryChangeSource): void;
-    /** @internal */
-    reconciled(): void;
-    /** @internal */
-    confirm(lsn: string): void;
-    /** The slot's confirmed position (tests). */
-    confirmed(): number | undefined;
-}
-declare class MemoryChangeSource implements ChangeSource {
-    private readonly record;
-    private handlers;
-    private timer;
-    private active;
-    private stopped;
-    constructor(record: MemoryRecord);
-    start(handlers: ChangeHandlers): void;
-    acknowledge(lsn: string): void;
-    reconciled(): Promise<void>;
-    stop(): Promise<void>;
-    /** @internal */
-    deliver(tx: CommittedTx): void;
-    /** @internal */
-    lost(error: Error): void;
-    private tryAttach;
-    private retry;
-}
-export {};