@rikalabs/akter 0.1.0-alpha.0

package/dist/runtime/turn/blobs.js

@@ -0,0 +1,215 @@
+import { Cause, Effect, Option, Predicate, Result, Schema, Stream } from "effect";
+import { SqlClient } from "effect/sql";
+import { inTenant, TenantScope } from "../database/tenancy.js";
+import { InvalidContentRef } from "../../errors/content.js";
+import { ContentRef } from "../../identity/content.js";
+import { isContent } from "../../members/blob.js";
+import { routingKey as routingKeyOf } from "../storage/codec.js";
+/** UTF-8 bytes of an entry name; the name shares a btree key with the ownership columns. */
+const MAX_NAME_BYTES = 512;
+/**
+ * Bytes one entry may hold. `get` returns an entry as one row, and the Postgres
+ * driver closes a connection on any message over 16 MiB, so an entry stays well below it.
+ */
+export const MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+const isContentRef = Schema.is(ContentRef);
+/**
+ * Binds blob capabilities to the calling fiber's turn or query. Every row is
+ * addressed by the trusted scope, so equal blob and entry names of two actors
+ * or tenants never meet; writes run on the turn's connection, inside its
+ * savepoint, and roll back with it. Off-turn contexts get read methods only,
+ * and turns get no content bytes.
+ *
+ * Declared blobs, names, and byte arrays are checked on every call, so misuse
+ * is a defect of the turn. Entry names reject lone surrogates, which Postgres
+ * would turn into U+FFFD and alias another name, and NUL. Byte arrays are
+ * copied on the way in and out, since the caller may reuse its buffer and a
+ * driver may decode into a pooled one. Content references count against the
+ * entry cap with the actor's own entries, and an existing entry stays
+ * writable at the cap; the quota is named only after a write changed nothing.
+ * A set overwrites chunk 0 and drops the rest in one statement that changes
+ * nothing past the quota, so a caught defect leaves the entry whole. Turns of
+ * one actor serialize on its generation lock, so an appended chunk index is
+ * free at insert. Attaching content verifies its grant by MAC without a read
+ * and requires the grant to outlive this shard's clock by the skew margin, so
+ * the tenant shard's sweep sees a horizon past this turn's commit. Content
+ * keys are required only when a content blob is used.
+ */
+export const bindBlobs = Effect.fnUntraced(function* (scope, write, content) {
+    const sql = yield* SqlClient.SqlClient;
+    const connection = yield* Effect.serviceOption(sql.transactionService);
+    const { role } = yield* TenantScope;
+    if (write && Option.isNone(connection))
+        return yield* Effect.die(new Error("Blob writes need the turn transaction"));
+    const { ref } = scope;
+    const routingKey = routingKeyOf({ ref, placement: scope.placement });
+    const owner = sql `routing_key = ${routingKey} AND tenant_id = ${ref.tenant}
+    AND actor_type = ${ref.actor} AND actor_id = ${ref.id}`;
+    const overQuota = Effect.suspend(() => Effect.die(new Error(`One actor's blobs hold at most ${scope.maxBytes} bytes (policy.maxBlobBytes)`)));
+    const references = sql `(SELECT count(*) FROM actor_content_refs WHERE ${owner})`;
+    const tooManyEntries = Effect.suspend(() => Effect.die(new Error(`One actor's blobs hold at most ${scope.maxEntries} entries (policy.maxBlobEntries)`)));
+    const declared = Effect.fnUntraced(function* (blob) {
+        yield* scope.guard;
+        if (!scope.blobs.includes(blob))
+            return yield* Effect.die(new Error(`${String(blob?.name)} is not a declared blob of ${ref.actor}`));
+    });
+    const entry = Effect.fnUntraced(function* (blob, name) {
+        yield* declared(blob);
+        if (!Predicate.isString(name) ||
+            name.length === 0 ||
+            new TextEncoder().encode(name).byteLength > MAX_NAME_BYTES ||
+            !name.isWellFormed() ||
+            name.includes("\u0000"))
+            return yield* Effect.die(new Error(`Blob entry names are well-formed strings of 1-${MAX_NAME_BYTES} UTF-8 bytes without NUL`));
+        return sql `${owner} AND blob = ${blob.name} AND name = ${name}`;
+    });
+    const run = (effect) => effect.pipe((bound) => Option.isSome(connection)
+        ? Effect.provideService(bound, sql.transactionService, connection.value)
+        : inTenant({ sql, role, tenant: ref.tenant })(bound), Effect.orDie);
+    /** Runs `use` on the checked address of one entry of `blob`. */
+    const atEntry = (blob, name, use) => run(Effect.flatMap(entry(blob, name), use));
+    const noted = (blob) => Effect.sync(() => scope.wrote?.(blob.name));
+    const contentAccess = (blob) => {
+        const bound = Effect.suspend(() => content === undefined
+            ? Effect.die(new Error("Content blobs need the runtime's content.keys"))
+            : Effect.succeed(content));
+        const list = run(Effect.gen(function* () {
+            yield* declared(blob);
+            const rows = yield* sql `
+            SELECT name, hash, size::float8 AS size FROM actor_content_refs
+            WHERE ${owner} AND blob = ${blob.name} ORDER BY name COLLATE "C"`;
+            return rows.map(({ name, hash, size }) => ({ name, hash, size }));
+        }));
+        const resolve = (name) => atEntry(blob, name, (where) => Effect.map(sql `
+            SELECT hash, size::float8 AS size FROM actor_content_refs WHERE ${where}`, ([found]) => Option.fromUndefinedOr(found)));
+        if (!write)
+            return {
+                get: (name) => Effect.gen(function* () {
+                    const { store } = yield* bound;
+                    const found = yield* resolve(name);
+                    if (Option.isNone(found))
+                        return Option.none();
+                    return yield* store
+                        .read(ref.tenant, found.value.hash, found.value.size)
+                        .pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.orDie);
+                }),
+                stream: (name) => Stream.unwrap(Effect.gen(function* () {
+                    const { store } = yield* bound;
+                    const found = yield* resolve(name);
+                    if (Option.isNone(found))
+                        return Stream.fail(new Cause.NoSuchElementError(`No content entry ${name}`));
+                    return store
+                        .stream(ref.tenant, found.value.hash, found.value.size, scope.timeoutMs)
+                        .pipe(Stream.provideService(SqlClient.SqlClient, sql));
+                })),
+                list,
+            };
+        return {
+            attach: (name, contentRef) => Effect.gen(function* () {
+                const { store, skewMs, offset } = yield* bound;
+                const where = yield* run(entry(blob, name));
+                if (!isContentRef(contentRef))
+                    return yield* InvalidContentRef.make({ reason: "malformed" });
+                const verified = yield* store.verify(contentRef.grant, {
+                    tenant: ref.tenant,
+                    hash: contentRef.hash,
+                    size: contentRef.size,
+                });
+                if (Result.isFailure(verified))
+                    return yield* InvalidContentRef.make({ reason: verified.failure });
+                const [checked] = yield* run(sql `WITH used AS (
+                SELECT ${verified.success} > floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint
+                    + ${offset() + skewMs} AS live,
+                  EXISTS (SELECT 1 FROM actor_content_refs WHERE ${where}) AS present,
+                  (SELECT count(*) FROM actor_blobs WHERE ${owner} AND chunk = 0) + ${references} AS entries),
+              attached AS (
+                INSERT INTO actor_content_refs (routing_key, tenant_id, actor_type, actor_id, blob, name, hash, size)
+                SELECT ${routingKey}, ${ref.tenant}, ${ref.actor}, ${ref.id}, ${blob.name}, ${name},
+                  ${contentRef.hash}, ${contentRef.size}
+                FROM used WHERE live AND (present OR entries < ${scope.maxEntries})
+                ON CONFLICT (routing_key, tenant_id, actor_type, actor_id, blob, name)
+                DO UPDATE SET hash = EXCLUDED.hash, size = EXCLUDED.size)
+              SELECT live, present OR entries < ${scope.maxEntries} AS fits FROM used`);
+                if (!checked.live)
+                    return yield* InvalidContentRef.make({ reason: "expired" });
+                if (!checked.fits)
+                    return yield* tooManyEntries;
+                yield* noted(blob);
+            }),
+            detach: (name) => atEntry(blob, name, (where) => Effect.andThen(sql `DELETE FROM actor_content_refs WHERE ${where}`, noted(blob))),
+            list,
+        };
+    };
+    const access = (blob) => {
+        if (isContent(blob))
+            return contentAccess(blob);
+        const copy = (bytes) => {
+            if (!(bytes instanceof Uint8Array))
+                return Effect.die(new Error("Blob bytes are a Uint8Array"));
+            return bytes.byteLength > MAX_ENTRY_BYTES ? oversized : Effect.succeed(Uint8Array.from(bytes));
+        };
+        const oversized = Effect.die(new Error(`A blob entry holds at most ${MAX_ENTRY_BYTES} bytes`));
+        const read = {
+            get: (name) => atEntry(blob, name, (where) => Effect.map(sql `
+              SELECT string_agg(bytes, ''::bytea ORDER BY chunk) AS bytes
+              FROM actor_blobs WHERE ${where}`, ([found]) => Option.map(Option.fromNullishOr(found?.bytes), (bytes) => Uint8Array.from(bytes)))),
+        };
+        if (!write)
+            return read;
+        const values = (name, chunk, bytes) => sql `${routingKey}::bigint, ${ref.tenant}, ${ref.actor}, ${ref.id}, ${blob.name}, ${name}, ${chunk}, ${bytes}::bytea`;
+        const usage = (where) => sql `
+        SELECT (count(*) FILTER (WHERE chunk = 0) + ${references})::float8 AS entries,
+          COALESCE(bool_or(${where}), false) AS present,
+          COALESCE(sum(octet_length(bytes)) FILTER (WHERE ${where}), 0)::float8 AS entry_bytes
+        FROM actor_blobs WHERE ${owner}`.pipe(Effect.map(([row]) => row));
+        const refused = (used) => !used.present && used.entries >= scope.maxEntries ? tooManyEntries : overQuota;
+        return {
+            ...read,
+            set: (name, bytes) => atEntry(blob, name, (where) => Effect.gen(function* () {
+                const copied = yield* copy(bytes);
+                const written = yield* sql `WITH used AS (
+                SELECT COALESCE(sum(octet_length(bytes)) FILTER (WHERE NOT (${where})), 0) AS other,
+                  count(*) FILTER (WHERE chunk = 0) + ${references} AS entries,
+                  COALESCE(bool_or(${where}), false) AS present
+                FROM actor_blobs WHERE ${owner}),
+              fits AS (
+                SELECT 1 FROM used WHERE other + ${copied.byteLength} <= ${scope.maxBytes}
+                  AND (present OR entries < ${scope.maxEntries})),
+              dropped AS (
+                DELETE FROM actor_blobs WHERE ${where} AND chunk > 0 AND EXISTS (SELECT 1 FROM fits))
+              INSERT INTO actor_blobs (routing_key, tenant_id, actor_type, actor_id, blob, name, chunk, bytes)
+              SELECT ${values(name, sql.literal("0"), copied)} FROM fits
+              ON CONFLICT (routing_key, tenant_id, actor_type, actor_id, blob, name, chunk)
+              DO UPDATE SET bytes = EXCLUDED.bytes
+              RETURNING chunk`;
+                if (written.length === 0)
+                    return yield* refused(yield* usage(where));
+                yield* noted(blob);
+            })),
+            append: (name, bytes) => atEntry(blob, name, (where) => Effect.gen(function* () {
+                const copied = yield* copy(bytes);
+                const inserted = yield* sql `INSERT INTO actor_blobs (routing_key, tenant_id, actor_type, actor_id, blob, name, chunk, bytes)
+              SELECT ${values(name, sql.literal("COALESCE(max(chunk) FILTER (WHERE entry) + 1, 0)"), copied)}
+              FROM (SELECT chunk, bytes, (${where}) AS entry FROM actor_blobs WHERE ${owner}) AS owned
+              HAVING COALESCE(sum(octet_length(bytes)) FILTER (WHERE entry), 0) + ${copied.byteLength} <= ${MAX_ENTRY_BYTES}
+                AND COALESCE(sum(octet_length(bytes)), 0) + ${copied.byteLength} <= ${scope.maxBytes}
+                AND (bool_or(entry) OR count(*) FILTER (WHERE chunk = 0) + ${references} < ${scope.maxEntries})
+              RETURNING chunk`;
+                if (inserted.length === 0) {
+                    const used = yield* usage(where);
+                    return yield* used.entry_bytes + copied.byteLength > MAX_ENTRY_BYTES
+                        ? oversized
+                        : refused(used);
+                }
+                yield* noted(blob);
+            })),
+            compact: (name) => atEntry(blob, name, (where) => Effect.andThen(sql `WITH merged AS (
+                DELETE FROM actor_blobs WHERE ${where} AND chunk > 0 RETURNING chunk, bytes)
+              UPDATE actor_blobs AS head
+              SET bytes = head.bytes || (SELECT string_agg(m.bytes, ''::bytea ORDER BY m.chunk) FROM merged AS m)
+              WHERE ${where} AND head.chunk = 0 AND EXISTS (SELECT 1 FROM merged)`, noted(blob))),
+            delete: (name) => atEntry(blob, name, (where) => Effect.andThen(sql `DELETE FROM actor_blobs WHERE ${where}`, noted(blob))),
+        };
+    };
+    return access;
+});

package/dist/runtime/turn/execute.d.ts

@@ -0,0 +1,208 @@
+import { Cause, Crypto, Effect, Result } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+import { ActorError } from "../../errors/actor.ts";
+import { type Broadcast, type ConnectionLister, type EmittedEvent, type RegisteredCommand } from "../members.ts";
+import { Outcome, type Request } from "../request.ts";
+import type { TurnPolicy } from "../../policies/command.ts";
+import { type CronEntry } from "../cron/schedule.ts";
+import type { WriteSet } from "../connections/protocol.ts";
+import type { UsageAccountingService } from "../telemetry/usage.ts";
+import { type ActivationCache } from "../storage/generation.ts";
+/** The events a turn committed: sequences `after + 1` onward, stamped `emittedAtMs`. */
+export interface CommittedEvents {
+    readonly after: string;
+    readonly events: ReadonlyArray<EmittedEvent>;
+    readonly commandId: string;
+    readonly emittedAtMs: number;
+}
+/** One command waiting in an activation's mailbox, with the handler it runs. */
+export interface Delivery {
+    readonly request: Request;
+    readonly command: RegisteredCommand;
+    /** Set only after this external id passes the fenced admission check. */
+    admitted?: boolean;
+}
+/**
+ * How one command of a batch ended: an outcome its receipt records or
+ * replays, or an admission error answered without a receipt.
+ */
+export type Settled = Result.Result<Outcome, ActorError>;
+/** Rows a committed turn adds; nothing when it replays, acknowledges, or rolls back. */
+export interface Written {
+    readonly receipts: number;
+    readonly events: number;
+    readonly intents: number;
+    readonly jobs: number;
+}
+/** What a committed or rolled-back batch answers. */
+export interface Done {
+    readonly settled: ReadonlyArray<Settled>;
+    /** Broadcasts the batch's committed successes publish to the actor's connections. */
+    readonly broadcasts: ReadonlyArray<Broadcast>;
+    /** The actor's event sequence once the batch commits. */
+    readonly head: string;
+    /** Each command's committed events, stamped, in delivery order. */
+    readonly committed: ReadonlyArray<CommittedEvents>;
+    /** Started jobs the batch's commands cancelled. */
+    readonly cancelledJobs: ReadonlyArray<string>;
+    readonly generation: string;
+    /** The positions in `settled` that answered from a stored receipt. */
+    readonly replays: ReadonlySet<number>;
+    /** Rows the batch committed; none when it rolled back. */
+    readonly written: Written;
+    /** The commit version each caller's later queries wait for. */
+    readonly version: string;
+    /** The database clock read on the turn's session after the transaction ended. */
+    readonly endedAtMs: number;
+    /** What the batch changed that a watched query may have read; nothing when it rolled back. */
+    readonly wrote: WriteSet;
+    /** The commit made outbox or subscription work due now, so the relay should claim it at once. */
+    readonly wake: boolean;
+    /** The commit cancelled a job attempt that is running, so running attempts should look now. */
+    readonly cancelled: boolean;
+}
+/**
+ * Consecutive batches of one activation. `next` takes the batch already
+ * waiting, if any, without waiting for one; `prepare` runs before each
+ * batch's handlers, and `committed` once the batch commits or rolls back,
+ * before the next batch's handlers run. `publishesUnderLock` names a batch
+ * whose `committed` may wait for the generation row lock in a transaction of
+ * its own; the next batch's admission would hold that lock until `committed`
+ * returns, so it is sent only after.
+ */
+interface Run<W extends Delivery, RN, RP, RC> {
+    readonly first: ReadonlyArray<W>;
+    readonly next: Effect.Effect<ReadonlyArray<W> | undefined, never, RN>;
+    readonly prepare: Effect.Effect<void, never, RP>;
+    readonly committed: (batch: ReadonlyArray<W>, done: Done) => Effect.Effect<void, never, RC>;
+    readonly publishesUnderLock: (batch: ReadonlyArray<W>) => boolean;
+    /** Wraps one batch's handlers, commit, and answers in that batch's own span and logs. */
+    readonly observe: (batch: ReadonlyArray<W>) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+/**
+ * Why a run stopped early: the batch that failed, a following batch whose
+ * admission was already sent and is rolled back unseen with it, and the cause.
+ * Batches before them committed and were answered. `committed` says the batch
+ * itself ended, committed or cleanly rolled back, and failed while its callers
+ * were being answered, so its commands must resolve through their receipts.
+ */
+export interface Stopped<W extends Delivery> {
+    readonly batch: ReadonlyArray<W>;
+    readonly orphan: ReadonlyArray<W> | undefined;
+    readonly cause: Cause.Cause<unknown>;
+    readonly committed: boolean;
+    /** The turn never leased a session, so no fence statement or handler was run. */
+    readonly poolRefused?: boolean;
+}
+/**
+ * Commands already waiting for one actor, run in delivery order in one
+ * framework transaction sent as two groups. The admission group opens the
+ * transaction, takes the generation fence, resolves every command's receipt
+ * under it, and on a cold activation acquires the next generation and reads
+ * state. The handlers run in memory once those replies arrive, each on the
+ * state the previous one left. The commit group writes the dirty state, each
+ * command's events and outbox rows, the creation marker, and every receipt,
+ * then commits. A lone command is a batch of one.
+ *
+ * Each command keeps its own outcome: a declared failure discards only its
+ * own staged work, and an admission error (expiry, `NotCreated`, a receipt
+ * conflict) answers only that command. A stale fence or any defect fails the
+ * whole batch and writes nothing. A batch with nothing to commit rolls back.
+ * Every command id in a batch must be distinct.
+ *
+ * `statements` marks an actor whose handler can issue SQL; only its handlers
+ * run under a savepoint, so a declared failure discards the handler's rows.
+ * The first handler's savepoint goes out with admission and each later one's
+ * with that handler's first statement. A handler that issued no statement has
+ * nothing to roll back, so its unsent savepoint is dropped. Rolling back to a
+ * savepoint keeps it, so each failed handler leaves one open until commit; a
+ * batch never holds more savepoints than its command cap. `parent` is a
+ * parent-placed actor's parent type, whose turns alone mint it, and `waited`
+ * holds the event tags workflows wait on.
+ *
+ * Admission statements take no parameter from another's reply, so they share
+ * one flight. The generation insert precedes the fenced read, so a brand-new
+ * actor's receipts resolve under the generation row lock. The timeout
+ * `set_config` runs before that insert, so `lock_timeout` bounds the insert's
+ * row waits but not the table lock taken as the statement starts;
+ * `statement_timeout` applies from the next statement. With row-level
+ * security the same statement takes the tenant role, which binds every later
+ * statement of the turn, the handler's included, to the actor's tenant at no
+ * extra round trip. A subscription delivery's cursor row is read in the
+ * fenced statement, and the delivery's canonical payload, not the event's
+ * bytes, binds its identity. When another runner advanced the generation
+ * since this activation acquired it, its cached state may be stale, so
+ * nothing runs, the activation drops its cache, and the retry reloads under a
+ * new generation.
+ *
+ * Admission checks. The generation row is locked in a materialized input
+ * before the read evaluates its clock, so time spent waiting for the fence
+ * cannot admit an identity that expired meanwhile. External ids are validated
+ * against the fenced read's clock before their receipt is released or a handler
+ * runs. An owner reports
+ * that admission on a retryable failure, so only a previously admitted
+ * redelivery can run past expiry, and not once retention could have pruned
+ * its receipt. No pre-delivery receipt read is needed. Only the relay's subscription
+ * deliveries reach a handler, and only a handler takes one, so no caller
+ * reaches it around the cursor or route. A routed event for a subscriber its
+ * creating command has not created is skipped, and its cursor keeps a stale
+ * redelivery from running after another command creates the subscriber. A
+ * minted actor is created only by the relay delivering the creating intent
+ * its parent's turn staged and committed: the mint proof binds the id to the
+ * parent's command, and the relay's claimed-row provenance proves that
+ * command committed the intent without reading another actor's shard.
+ *
+ * Handlers and commit. Calls of a commutative reducer already waiting right
+ * behind a command merge into its turn: their inputs are combined and reduced
+ * once. A complete result lists every key it keeps, and any other key it was
+ * given is deleted. A delivery's cursor position is applied with its receipt,
+ * declared failures included. Re-arming waiting workflows reads their steps,
+ * so it runs before the commit group and only an actor with a workflow
+ * waiting on an emitted class pays for it. A cold activation that replays or
+ * acknowledges still commits and keeps the generation it acquired, so work
+ * the replay wakes runs under it. The first batch a generation commits
+ * schedules every cron entry not yet ticking from the database clock after
+ * its handlers ran, so a first tick is never due before the batch that
+ * writes it. A batch's work is bounded like a lone turn's: interruption and
+ * the command timeout roll it back, and SQL failures are defects. A failed or
+ * unknown commit leaves nothing the cached state can be trusted for, so it
+ * clears the cache.
+ *
+ * On Postgres a run uses one leased session. Each admission group opens with
+ * `BEGIN`, and each commit group ends with `COMMIT`, whose command tag must
+ * be `COMMIT`, since Postgres answers `COMMIT` in an aborted transaction with
+ * `ROLLBACK`. While batch N commits, the next batch already waiting sends its
+ * `BEGIN` and admission group in the same flight, right behind N's `COMMIT`:
+ * the server runs them strictly after it, as a new transaction on the same
+ * session. That admission is built as if N commits, which its fence proves. A
+ * batch that leaves the cache cold is committed alone, so the next one
+ * prepares, which may acquire the generation itself, before its admission
+ * locks the generation row. So is a batch whose publication may wait for that
+ * lock in another transaction: an admission already behind its `COMMIT` would
+ * hold the lock until the publication it waits on ends, and neither would
+ * ever finish. N's callers are answered once its `COMMIT` reply
+ * arrives, and the next batch's handlers run only once its own fence and
+ * receipt replies arrive. If N's commit fails, the next batch's transaction
+ * is rolled back unseen with it. The commit version is read on the same
+ * session after the transaction ends, in the same flight, so it covers the
+ * batch's commit record and any receipt it replayed. The same statement reads
+ * a fresh clock after the transaction ended for the external expiry recheck,
+ * never reusing admission time.
+ *
+ * The session is unsafe from the moment a `BEGIN` may be queued until a
+ * transaction-ending reply with nothing queued behind it. Any other exit
+ * rolls back, and a session whose transaction state is unknown never goes
+ * back to the pool: an interrupted batch cancels its backend's statement and
+ * discards the session, so an unsent `COMMIT` rolls back with it and one
+ * already sent resolves through the receipt on retry. Deferred statements go
+ * out in the same flight as the next statement a handler sends, or at the
+ * head of the commit group.
+ */
+export declare const executeBatches: <W extends Delivery, RN, RP, RC>(run: Run<W, RN, RP, RC>, cache: ActivationCache, routingKey: bigint, policy: TurnPolicy, mintable: boolean, parent: string | undefined, statements: boolean, waited?: ReadonlySet<string> | undefined, connections?: ConnectionLister | undefined, cron?: readonly CronEntry[] | undefined, accounting?: UsageAccountingService | undefined) => Effect.Effect<{
+    batch: readonly W[];
+    orphan: readonly W[] | undefined;
+    cause: Cause.Cause<SqlError.SqlError>;
+    committed: false;
+    poolRefused: false;
+} | undefined, SqlError.SqlError, RC | RN | RP | Crypto.Crypto | SqlClient.SqlClient>;
+export {};