ramosedb 0.0.1 → 0.4.0

package/dist/internal/transactor/transactor.js

@@ -0,0 +1,1166 @@
+import { ChangesetService, decodeChangesetCommand } from "../changesets/service.js";
+import { changesetConflict, changesetSubject } from "../authorization/changesets.js";
+import { Connection, TxError, bootstrapDatoms, decodeLogChunk, emptyRoots, encodeLogChunk, fromJson, gzipCodec, toJson, txFrame, FIRST_USER_EID, Histogram, RateMeter, componentLogger, toWireDatom, VALUE_TYPE_IDENTS, } from "../core/index.js";
+import { InvalidRequest, OperationRejected, TxRejected, Unauthorized, } from "../../db/Errors.js";
+import { R2NodeStore, readCurrentRoot, recordToRoots, rootsToRecord } from "../storage/index.js";
+import * as Effect from "effect/Effect";
+import { BadRequest, NotFound, TransactorDeadError, Unavailable, errorResponse, toHttpError } from "./errors.js";
+import {} from "./host.js";
+import { Indexer } from "./indexer.js";
+import { TxMetrics } from "./observability.js";
+import { inertRuntimeBoundaries, } from "../runtime-boundaries.js";
+import { allocationMappingsResolvable, authorizeCatalogOperation, authorizeCatalogOperationGrant, authorizeCatalogOperationReplay, catalogProvisioningAttributes, decideEpoch, decideInvocationReceipt, deployedOperationInputWireShape, deployedOperationOutputWireShape, deployedOperationVersion, executeCatalogOperation, inputEntityRefHandles, invocationReceiptOutcome, isLegacyInvocationReceiptRow, OperationRuntimeFault, opaqueOperationDenial, outputEntityRefPaths, parseEntityIdScope, parseInvocationAllocations, parseStoredInvocationReceipt, prepareInvocationReceipt, requireSuppliedOperationVersion, resolveOperationCatalog, resolveSealedInputRefs, resolveSealedTarget, transitionInvocationReceipt, } from "../authorization/index.js";
+export { TransactorDeadError };
+function asPrincipal(x) {
+    if (typeof x !== "object" || x === null || Array.isArray(x))
+        return undefined;
+    const o = x;
+    if (o.kind !== "user" || typeof o.class !== "string")
+        return undefined;
+    const claims = typeof o.claims === "object" && o.claims !== null
+        ? o.claims
+        : {};
+    const classes = Array.isArray(o.classes)
+        ? o.classes.filter((c) => typeof c === "string")
+        : undefined;
+    return {
+        kind: "user",
+        class: o.class,
+        claims,
+        ...(typeof o.sub === "string" ? { sub: o.sub } : {}),
+        ...(typeof o.eid === "number" ? { eid: o.eid } : {}),
+        ...(classes !== undefined && classes.length > 0 ? { classes } : {}),
+    };
+}
+const RECENT_CLIENT_TX_LIMIT = 256;
+export function clientTxReplayKey(principal, id) {
+    if (!principal)
+        return `\0:${id}`;
+    const who = principal.sub ?? (principal.eid !== undefined ? `#${principal.eid}` : principal.class);
+    return `${principal.kind}\0${who}\0${id}`;
+}
+const yieldToEventLoop = () => new Promise((r) => setTimeout(r, 0));
+const round = (x) => Math.round(x * 100) / 100;
+const safeName = (host) => {
+    try {
+        return host.dbName;
+    }
+    catch {
+        return undefined;
+    }
+};
+const json = (body, status = 200, headers = {}) => new Response(JSON.stringify(toJson(body)), { status, headers: { "content-type": "application/json", ...headers } });
+export class Transactor {
+    host;
+    operationRuntime;
+    boundaries;
+    ready;
+    conn;
+    store;
+    rootRecord;
+    logWatermark = 0;
+    queue = [];
+    committing = false;
+    indexer;
+    txSinceIndex = 0;
+    dead;
+    recentAcks = new Map();
+    stats = { txs: 0, batches: 0, maxBatch: 0, rejected: 0, indexRuns: 0, broadcasts: 0, commitMs: 0, resolveMs: 0, loopMs: 0, fenceMs: 0 };
+    txRate = new RateMeter(10_000);
+    batchSizes = new Histogram([1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]);
+    commitLatency = new Histogram();
+    resolveLatency = new Histogram();
+    loopLatency = new Histogram();
+    fenceLatency = new Histogram();
+    metrics;
+    log;
+    deployedComposition;
+    constructor(host, operationRuntime, boundaries = inertRuntimeBoundaries) {
+        this.host = host;
+        this.operationRuntime = operationRuntime;
+        this.boundaries = boundaries;
+        this.log = componentLogger("transactor", () => ({ db: safeName(host) }));
+        this.metrics = new TxMetrics(host.analytics);
+    }
+    bindComposition(unitHash, index) {
+        const current = this.deployedComposition;
+        if (current !== undefined) {
+            if (current.unitHash !== unitHash) {
+                throw new TxError("cannot change deployed catalog composition", "tx/system");
+            }
+            return;
+        }
+        this.deployedComposition = { unitHash, index };
+        if (this.conn !== undefined)
+            this.conn.bindComposition(index);
+    }
+    init() {
+        if (!this.ready)
+            this.ready = this.boot();
+        return this.ready;
+    }
+    async boot() {
+        const sql = this.host.sql;
+        this.proposalService.initialize();
+        sql.exec(`CREATE TABLE IF NOT EXISTS log (t INTEGER PRIMARY KEY, tx_instant INTEGER NOT NULL, datoms BLOB NOT NULL)`);
+        sql.exec(`CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL)`);
+        sql.exec(`CREATE TABLE IF NOT EXISTS operation_receipts (
+      principal_id TEXT NOT NULL,
+      invocation_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      receipt TEXT NOT NULL,
+      PRIMARY KEY (principal_id, invocation_id)
+    )`);
+        this.store = new R2NodeStore(this.host.bucket, { codec: gzipCodec, maxNodes: 4096 });
+        let rec = this.getMeta("root") ?? (await readCurrentRoot(this.host.bucket));
+        if (!rec) {
+            const roots = await emptyRoots(this.store);
+            const fresh = rootsToRecord(roots, { log_watermark: 0, next_eid: FIRST_USER_EID, codec: gzipCodec.name });
+            const boot = bootstrapDatoms();
+            this.host.transactionSync(() => {
+                this.appendLogRow({ t: 1, txInstant: this.host.now(), datoms: boot });
+                this.setMeta("root", fresh);
+                this.setMeta("next_eid", FIRST_USER_EID);
+            });
+            rec = fresh;
+        }
+        this.rootRecord = rec;
+        this.logWatermark = rec.log_watermark;
+        const roots = recordToRoots(rec);
+        const nextEid = this.getMeta("next_eid") ?? rec.next_eid;
+        const logDatoms = this.readLogDatoms(roots.t);
+        this.conn = await Connection.restore(this.store, roots, logDatoms, nextEid, {
+            now: () => this.host.now(),
+            ...(this.deployedComposition === undefined
+                ? {}
+                : { composition: this.deployedComposition.index }),
+        });
+        if (this.deployedComposition !== undefined) {
+            this.conn.bindComposition(this.deployedComposition.index);
+        }
+        this.txSinceIndex = Math.max(0, this.conn.t - roots.t);
+        const c = this.host.config;
+        this.indexer = new Indexer(this, {
+            intervalMs: c.indexIntervalMs,
+            txThreshold: c.indexTxThreshold,
+            maxTxsPerRun: c.indexMaxTxsPerRun,
+            logKeepTxs: c.logKeepTxs,
+            gcEveryN: c.gcEveryNIndexes,
+            retainRoots: c.retainRoots,
+        }, this.boundaries);
+        if (this.conn.t > roots.t)
+            await this.indexer.schedule();
+        await this.proposalService.schedule();
+        this.log.info("boot", { t: this.conn.t, rootT: roots.t, novelty: this.conn.noveltyCount, nextEid: this.conn.nextEntityId, fresh: !this.getMeta("root") });
+    }
+    getMeta(k) {
+        const row = this.host.sql.exec(`SELECT v FROM meta WHERE k = ?`, k).toArray()[0];
+        return row ? JSON.parse(row.v) : undefined;
+    }
+    setMeta(k, v) {
+        this.host.sql.exec(`INSERT OR REPLACE INTO meta (k, v) VALUES (?, ?)`, k, JSON.stringify(v));
+    }
+    appendLogRow(e) {
+        const body = encodeLogChunk([e]);
+        const buf = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+        this.host.sql.exec(`INSERT INTO log (t, tx_instant, datoms) VALUES (?, ?, ?)`, e.t, e.txInstant, buf);
+    }
+    readInvocationReceipt(principalId, invocationId) {
+        const row = this.host.sql.exec(`SELECT status, receipt FROM operation_receipts
+       WHERE principal_id = ? AND invocation_id = ?`, principalId, invocationId).toArray()[0];
+        if (row === undefined)
+            return undefined;
+        const receipt = parseStoredInvocationReceipt(JSON.parse(row.receipt));
+        if (isLegacyInvocationReceiptRow(receipt))
+            return receipt;
+        if (row.status !== receipt.status) {
+            throw new TypeError("durable invocation receipt status mismatch");
+        }
+        return receipt;
+    }
+    insertInvocationReceipt(receipt) {
+        this.host.sql.exec(`INSERT INTO operation_receipts
+       (principal_id, invocation_id, status, receipt) VALUES (?, ?, ?, ?)`, receipt.principalId, receipt.invocationId, receipt.status, JSON.stringify(receipt));
+    }
+    replaceInvocationReceipt(receipt) {
+        this.host.sql.exec(`UPDATE operation_receipts SET status = ?, receipt = ?
+       WHERE principal_id = ? AND invocation_id = ?`, receipt.status, JSON.stringify(receipt), receipt.principalId, receipt.invocationId);
+    }
+    claimInvocationReceipt(prepared) {
+        return this.host.transactionSync(() => {
+            const stored = this.readInvocationReceipt(prepared.principalId, prepared.invocationId);
+            const decision = decideInvocationReceipt(stored, prepared);
+            if (decision._tag === "Claim") {
+                this.insertInvocationReceipt(decision.receipt);
+            }
+            else if (decision._tag === "Recover") {
+                this.replaceInvocationReceipt(decision.receipt);
+            }
+            return decision;
+        });
+    }
+    inspectInvocationReceipt(prepared) {
+        const stored = this.readInvocationReceipt(prepared.principalId, prepared.invocationId);
+        return decideInvocationReceipt(stored, prepared);
+    }
+    recoverInvocationReceipt(prepared) {
+        return this.host.transactionSync(() => {
+            const stored = this.readInvocationReceipt(prepared.principalId, prepared.invocationId);
+            const decision = decideInvocationReceipt(stored, prepared);
+            if (decision._tag === "Recover") {
+                this.replaceInvocationReceipt(decision.receipt);
+            }
+            return decision;
+        });
+    }
+    assertClaimIdentity(stored, claim) {
+        if (stored === undefined || isLegacyInvocationReceiptRow(stored) ||
+            stored.status !== "claimed" || stored.version !== claim.version ||
+            stored.principalId !== claim.principalId ||
+            stored.invocationId !== claim.invocationId ||
+            stored.scopeDigest !== claim.scopeDigest ||
+            stored.operationVersion !== claim.operationVersion ||
+            stored.invocationDigest !== claim.invocationDigest) {
+            throw new Error("durable invocation claim changed before completion");
+        }
+    }
+    finishInvocationReceipt(claim, event, insideTransaction = false) {
+        const finish = () => {
+            const stored = this.readInvocationReceipt(claim.principalId, claim.invocationId);
+            this.assertClaimIdentity(stored, claim);
+            const terminal = transitionInvocationReceipt(stored, event);
+            this.replaceInvocationReceipt(terminal);
+            return terminal;
+        };
+        return insideTransaction ? finish() : this.host.transactionSync(finish);
+    }
+    readLogEntries(from, to = Number.MAX_SAFE_INTEGER, limit = 100_000) {
+        const rows = this.host.sql.exec(`SELECT t, tx_instant, datoms FROM log WHERE t > ? AND t <= ? ORDER BY t LIMIT ?`, from, to, limit).toArray();
+        const out = [];
+        for (const r of rows) {
+            const raw = r.datoms;
+            const buf = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+            const [entry] = decodeLogChunk(buf);
+            out.push(entry);
+        }
+        return out;
+    }
+    readLogDatoms(afterT) {
+        const out = [];
+        for (const e of this.readLogEntries(afterT))
+            for (const d of e.datoms)
+                out.push(d);
+        return out;
+    }
+    earliestLogT() {
+        const row = this.host.sql.exec(`SELECT MIN(t) AS t FROM log`).toArray()[0];
+        return row?.t ?? 0;
+    }
+    pruneLog(throughT) {
+        const before = this.host.sql.exec(`SELECT COUNT(*) AS n FROM log WHERE t <= ?`, throughT).toArray()[0].n;
+        this.host.sql.exec(`DELETE FROM log WHERE t <= ?`, throughT);
+        return before;
+    }
+    get connection() {
+        return this.conn;
+    }
+    get nodeStore() {
+        return this.store;
+    }
+    get bucket() {
+        return this.host.bucket;
+    }
+    get currentRootRecord() {
+        return this.rootRecord;
+    }
+    get watermark() {
+        return this.logWatermark;
+    }
+    get t() {
+        return this.conn.t;
+    }
+    get txsSinceIndex() {
+        return this.txSinceIndex;
+    }
+    get isDead() {
+        return this.dead !== undefined;
+    }
+    adoptRoot(rec) {
+        this.rootRecord = rec;
+        this.logWatermark = rec.log_watermark;
+        this.setMeta("root", rec);
+        this.txSinceIndex = Math.max(0, this.conn.t - rec.t);
+        this.stats.indexRuns++;
+        this.broadcast({ v: 1, kind: "root", root: rec });
+    }
+    transact(tx, principal, clientTxId, extras) {
+        if (this.dead !== undefined)
+            return Promise.reject(new TransactorDeadError(this.dead));
+        if (clientTxId !== undefined) {
+            const key = clientTxReplayKey(principal, clientTxId);
+            const hit = this.recentAcks.get(key);
+            if (hit)
+                return Promise.resolve(hit);
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                tx,
+                principal,
+                clientTxId,
+                system: extras?.system || undefined,
+                resolve: resolve,
+                reject,
+            });
+            if (!this.committing) {
+                this.committing = true;
+                void this.commitLoop();
+            }
+        });
+    }
+    replayableMappings(receipt, context) {
+        if (receipt.status !== "completed" || receipt.allocations === undefined) {
+            return true;
+        }
+        if (context === undefined)
+            return false;
+        return allocationMappingsResolvable(receipt.allocations, {
+            keyId: context.sealing.keyId,
+            scope: context.scope,
+        });
+    }
+    decideInvocationEpoch(p, inputHandles) {
+        const operation = p.operation;
+        if (!this.usesOpaqueHandles(operation, inputHandles)) {
+            return { _tag: "Agreed", context: undefined };
+        }
+        const scope = operation.entityIdScope;
+        const keyId = operation.entityIdKeyId;
+        if (p.sealing === undefined || scope === undefined || keyId === undefined) {
+            throw opaqueOperationDenial();
+        }
+        const decision = decideEpoch({ keyId, scope }, p.sealing);
+        if (decision._tag === "UpdateRequired")
+            return decision;
+        return {
+            _tag: "Agreed",
+            context: { sealing: decision.sealing, scope: decision.scope },
+        };
+    }
+    usesOpaqueHandles(invocation, inputHandles) {
+        return invocation.sealedTarget !== undefined ||
+            (invocation.allocations !== undefined && invocation.allocations.length > 0) ||
+            inputHandles.length > 0;
+    }
+    needsSealingKey(invocation) {
+        return invocation.sealedTarget !== undefined ||
+            (invocation.allocations !== undefined && invocation.allocations.length > 0) ||
+            invocation.entityIdScope !== undefined;
+    }
+    async resolveInvocationTarget(p, context) {
+        const invocation = p.operation;
+        if (invocation.sealedTarget === undefined)
+            return invocation;
+        if (invocation.target !== undefined)
+            throw opaqueOperationDenial();
+        if (context === undefined)
+            throw opaqueOperationDenial();
+        const resolution = await resolveSealedTarget(context.sealing, context.scope, invocation.sealedTarget);
+        if (resolution._tag === "UpdateRequired")
+            return undefined;
+        if (resolution._tag === "Denied")
+            throw opaqueOperationDenial();
+        return Object.freeze({ ...invocation, target: resolution.eid });
+    }
+    async resolveInvocationInput(invocation, context, inputHandles) {
+        if (inputHandles.length === 0)
+            return invocation;
+        if (context === undefined)
+            throw opaqueOperationDenial();
+        const resolution = await resolveSealedInputRefs(context.sealing, context.scope, invocation.input, inputHandles);
+        if (resolution._tag === "UpdateRequired")
+            return undefined;
+        if (resolution._tag === "Denied")
+            throw opaqueOperationDenial();
+        return Object.freeze({ ...invocation, input: resolution.input });
+    }
+    async invoke(invocation) {
+        if (this.dead !== undefined)
+            throw new TransactorDeadError(this.dead);
+        const runtime = this.operationRuntime;
+        if (runtime === undefined)
+            throw opaqueOperationDenial();
+        let sealing;
+        if (this.needsSealingKey(invocation)) {
+            if (runtime.sealing === undefined || invocation.entityIdScope === undefined) {
+                throw opaqueOperationDenial();
+            }
+            try {
+                sealing = await runtime.sealing();
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                this.log.error("operation.sealing-root-unavailable", { error: message });
+                throw new Unavailable({
+                    message: "the server sealing root is momentarily unavailable",
+                    retryAfterMs: 1_000,
+                });
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                tx: [],
+                operation: invocation,
+                ...(sealing === undefined ? {} : { sealing }),
+                resolve: resolve,
+                reject,
+            });
+            if (!this.committing) {
+                this.committing = true;
+                void this.commitLoop();
+            }
+        });
+    }
+    serialized(run) {
+        if (this.dead !== undefined)
+            return Promise.reject(new TransactorDeadError(this.dead));
+        return new Promise((resolve, reject) => {
+            this.queue.push({ reject, task: async () => {
+                    try {
+                        resolve(await run());
+                    }
+                    catch (cause) {
+                        reject(cause);
+                    }
+                } });
+            if (!this.committing) {
+                this.committing = true;
+                void this.commitLoop();
+            }
+        });
+    }
+    proposalHandler;
+    get proposalService() {
+        if (this.proposalHandler !== undefined)
+            return this.proposalHandler;
+        const owner = this;
+        return this.proposalHandler = new ChangesetService({
+            get sql() { return owner.host.sql; },
+            get database() { return safeName(owner.host) ?? ""; },
+            schedule: (deadline) => this.scheduleAlarm(deadline),
+            serialized: (run) => this.serialized(run),
+            current: () => this.conn,
+            checkpoint: () => this.boundaries.checkpoint("changeset.prepare"),
+            transactionSync: (run) => this.host.transactionSync(run),
+            reserve: (next) => this.setMeta("next_eid", next),
+            resolve: (operations, caller) => this.resolveChangesetOperations(operations, caller),
+            commit: async (entry, caller, persist) => {
+                const next = this.conn.fork();
+                next.applyDatoms(entry.datoms);
+                await this.boundaries.checkpoint("changeset.commit");
+                changesetSubject(caller, this.operationRuntime.now());
+                this.host.transactionSync(() => {
+                    this.boundaries.checkpointSync("changeset.commit.write");
+                    this.appendLogRow(entry);
+                    this.setMeta("next_eid", next.nextEntityId);
+                    persist();
+                });
+                this.conn.applyDatoms(entry.datoms);
+                this.txSinceIndex++;
+                this.stats.txs++;
+                this.broadcast(txFrame(entry));
+                await this.indexer.maybeSchedule();
+            },
+        });
+    }
+    async resolveChangesetOperations(rawOperations, caller) {
+        const runtime = this.operationRuntime;
+        const operations = [];
+        for (const raw of rawOperations) {
+            const invocation = { ...raw, caller };
+            if (invocation.database !== safeName(this.host))
+                throw opaqueOperationDenial();
+            const resolved = await Effect.runPromise(resolveOperationCatalog(runtime, invocation));
+            this.bindComposition(resolved.deployed.definition.unitHash, resolved.deployed.definition.composition);
+            const inputShape = deployedOperationInputWireShape(resolved, invocation.owner, invocation.localName);
+            if (inputShape === undefined)
+                throw opaqueOperationDenial();
+            const paths = inputEntityRefHandles(inputShape, invocation.input);
+            const sealing = this.needsSealingKey(invocation) ? await runtime.sealing?.() : undefined;
+            const pending = { operation: invocation, sealing };
+            const epoch = this.decideInvocationEpoch(pending, paths);
+            if (epoch._tag !== "Agreed")
+                throw changesetConflict("invocation_update_required");
+            const target = await this.resolveInvocationTarget(pending, epoch.context);
+            if (target === undefined)
+                throw changesetConflict("invocation_update_required");
+            const operation = await this.resolveInvocationInput(target, epoch.context, paths);
+            if (operation === undefined)
+                throw changesetConflict("invocation_update_required");
+            operations.push(operation);
+        }
+        return operations;
+    }
+    retainedRevisionRoots() { return this.proposalService.revisions.roots(); }
+    async changeset(command) {
+        const runtime = this.operationRuntime;
+        if (runtime === undefined)
+            throw opaqueOperationDenial();
+        if (command.action === "watch" || command.action === "list")
+            return this.proposalService.execute(this.conn, runtime, command);
+        if (command.action === "inspect" || command.action === "query" || command.action === "read") {
+            const snapshot = await this.serialized(async () => {
+                const stored = this.proposalService.load(command.id);
+                const release = stored?.baseRevision === undefined ? () => { } : this.proposalService.revisions.retain(stored.baseRevision);
+                return { connection: this.conn.fork(), stored, release };
+            });
+            try {
+                await this.boundaries.checkpoint("changeset.read");
+                return await this.proposalService.execute(snapshot.connection, runtime, command, snapshot);
+            }
+            finally {
+                snapshot.release();
+            }
+        }
+        if (command.action === "prepare" || command.action === "append")
+            return this.proposalService.execute(this.conn.fork(), runtime, command);
+        return this.serialized(() => this.proposalService.execute(this.conn, runtime, command));
+    }
+    async provisionCatalog(definition) {
+        await this.init();
+        this.bindComposition(definition.unitHash, definition.composition);
+        const attributes = catalogProvisioningAttributes(definition);
+        let missing = false;
+        for (const expected of attributes) {
+            const existing = this.conn.db().attr(expected[":db/ident"]);
+            if (existing === undefined) {
+                missing = true;
+                continue;
+            }
+            const expectedValueType = VALUE_TYPE_IDENTS[expected[":db/valueType"]];
+            const expectedUnique = expected[":db/unique"] === undefined
+                ? undefined
+                : expected[":db/unique"] === ":db.unique/identity"
+                    ? "identity"
+                    : "value";
+            const expectedCardinality = expected[":db/cardinality"] ===
+                ":db.cardinality/many"
+                ? "many"
+                : "one";
+            if (existing.valueType !== expectedValueType ||
+                existing.cardinality !== expectedCardinality ||
+                existing.unique !== expectedUnique ||
+                existing.index !== (expected[":db/index"] === true) ||
+                existing.isComponent !== (expected[":db/isComponent"] === true) ||
+                (existing.optional === true) !== (expected[":db/optional"] === true)) {
+                throw new TxError(`cannot provision incompatible deployed field ${expected[":db/ident"]}`, "tx/system");
+            }
+        }
+        if (!missing)
+            return this.conn.t;
+        const ack = await this.transact([...attributes], undefined, undefined, { system: true });
+        return ack.t;
+    }
+    async provision(principal) {
+        await this.init();
+        if (!principal)
+            return { eid: null, class: "" };
+        return { eid: principal.eid ?? null, class: principal.class };
+    }
+    rememberAck(id, ack) {
+        this.recentAcks.set(id, ack);
+        while (this.recentAcks.size > RECENT_CLIENT_TX_LIMIT) {
+            const first = this.recentAcks.keys().next().value;
+            if (first === undefined)
+                break;
+            this.recentAcks.delete(first);
+        }
+    }
+    invocationFailureEvent(error) {
+        let rejection;
+        if (error instanceof Unauthorized) {
+            rejection = { kind: "unauthorized" };
+        }
+        else if (error instanceof InvalidRequest) {
+            rejection = { kind: "invalid_request" };
+        }
+        else if (error instanceof OperationRejected) {
+            rejection = {
+                kind: "operation_rejected",
+                message: error.message,
+                operation: error.operation,
+                ...(error.step === undefined ? {} : { step: error.step }),
+                ...(error.reason === undefined ? {} : { reason: error.reason }),
+            };
+        }
+        else if (error instanceof TxRejected || error instanceof TxError) {
+            rejection = { kind: "request_rejected" };
+        }
+        return rejection === undefined
+            ? { _tag: "Fail" }
+            : { _tag: "Reject", rejection };
+    }
+    takeBatch() {
+        const batch = [];
+        const max = this.host.config.maxBatch;
+        while (this.queue.length > 0 && (max <= 0 || batch.length < max)) {
+            const next = this.queue[0];
+            if ("task" in next || (next.operation !== undefined && batch.length > 0))
+                break;
+            this.queue.shift();
+            batch.push(next);
+            if (next.operation !== undefined)
+                break;
+        }
+        return batch;
+    }
+    async commitLoop() {
+        try {
+            await this.init();
+            const fences = this.host.config.timingYields;
+            while (this.queue.length > 0 && this.dead === undefined) {
+                await yieldToEventLoop();
+                const next = this.queue[0];
+                if (next !== undefined && "task" in next) {
+                    this.queue.shift();
+                    await next.task();
+                    continue;
+                }
+                let fenceMs = 0;
+                if (fences) {
+                    const tFence = performance.now();
+                    await yieldToEventLoop();
+                    fenceMs = performance.now() - tFence;
+                    this.stats.fenceMs += fenceMs;
+                    this.fenceLatency.observe(fenceMs);
+                }
+                const queueDepth = this.queue.length;
+                const tLoop = performance.now();
+                const batch = this.takeBatch();
+                const entries = [];
+                const acks = [];
+                const batchAcks = new Map();
+                const tResolve = performance.now();
+                for (const p of batch) {
+                    if (p.operation !== undefined) {
+                        let claim;
+                        try {
+                            if (this.operationRuntime === undefined) {
+                                throw opaqueOperationDenial();
+                            }
+                            const supplied = requireSuppliedOperationVersion(p.operation.operationVersion);
+                            const resolved = await Effect.runPromise(resolveOperationCatalog(this.operationRuntime, p.operation));
+                            this.bindComposition(resolved.deployed.definition.unitHash, resolved.deployed.definition.composition);
+                            const operationVersion = deployedOperationVersion(resolved, p.operation.owner, p.operation.localName);
+                            if (operationVersion === undefined)
+                                throw opaqueOperationDenial();
+                            const inputWireShape = deployedOperationInputWireShape(resolved, p.operation.owner, p.operation.localName);
+                            if (inputWireShape === undefined)
+                                throw opaqueOperationDenial();
+                            const inputHandles = inputEntityRefHandles(inputWireShape, p.operation.input);
+                            const outputWireShape = deployedOperationOutputWireShape(resolved, p.operation.owner, p.operation.localName);
+                            const outcomeOf = (receipt) => {
+                                const outcome = invocationReceiptOutcome(receipt);
+                                if (outcome._tag !== "Completed" || outputWireShape === undefined) {
+                                    return outcome;
+                                }
+                                const outputRefPaths = outputEntityRefPaths(outputWireShape, outcome.output);
+                                return outputRefPaths.length === 0
+                                    ? outcome
+                                    : { ...outcome, outputRefPaths };
+                            };
+                            const operationRuntime = this.operationRuntime;
+                            const resolveCompatibility = async (tag) => {
+                                await authorizeCatalogOperationGrant(this.conn, operationRuntime, p.operation, resolved);
+                                this.stats.rejected++;
+                                p.resolve({ _tag: tag });
+                            };
+                            if (supplied !== undefined && supplied !== operationVersion) {
+                                await resolveCompatibility("OperationChanged");
+                                continue;
+                            }
+                            const epoch = this.decideInvocationEpoch(p, inputHandles);
+                            if (epoch._tag === "UpdateRequired") {
+                                await resolveCompatibility("UpdateRequired");
+                                continue;
+                            }
+                            const sealingContext = epoch.context;
+                            const targeted = await this.resolveInvocationTarget(p, sealingContext);
+                            if (targeted === undefined) {
+                                await resolveCompatibility("UpdateRequired");
+                                continue;
+                            }
+                            const operation = await this.resolveInvocationInput(targeted, sealingContext, inputHandles);
+                            if (operation === undefined) {
+                                await resolveCompatibility("UpdateRequired");
+                                continue;
+                            }
+                            const prepared = await Effect.runPromise(prepareInvocationReceipt(operation, operationVersion));
+                            const inspected = this.inspectInvocationReceipt(prepared);
+                            if (inspected._tag === "OperationChanged" ||
+                                inspected._tag === "UpdateRequired") {
+                                await resolveCompatibility(inspected._tag);
+                                continue;
+                            }
+                            if (inspected._tag === "Conflict") {
+                                this.stats.rejected++;
+                                p.resolve({ _tag: "Conflict" });
+                                continue;
+                            }
+                            if (inspected._tag === "Recover") {
+                                const recovered = this.recoverInvocationReceipt(prepared);
+                                if (recovered._tag === "OperationChanged" ||
+                                    recovered._tag === "UpdateRequired") {
+                                    await resolveCompatibility(recovered._tag);
+                                    continue;
+                                }
+                                if (recovered._tag === "Conflict") {
+                                    this.stats.rejected++;
+                                    p.resolve({ _tag: "Conflict" });
+                                    continue;
+                                }
+                                if (recovered._tag === "Replay" || recovered._tag === "Recover") {
+                                    if (!this.replayableMappings(recovered.receipt, sealingContext)) {
+                                        await resolveCompatibility("UpdateRequired");
+                                        continue;
+                                    }
+                                    p.resolve(outcomeOf(recovered.receipt));
+                                    continue;
+                                }
+                            }
+                            if (inspected._tag === "Replay") {
+                                if (!this.replayableMappings(inspected.receipt, sealingContext)) {
+                                    await resolveCompatibility("UpdateRequired");
+                                    continue;
+                                }
+                                if (inspected.receipt.status === "completed") {
+                                    await authorizeCatalogOperationReplay(this.conn, this.operationRuntime, operation, inspected.receipt.replayFence, resolved);
+                                }
+                                else {
+                                    await authorizeCatalogOperation(this.conn, this.operationRuntime, operation, resolved);
+                                }
+                                p.resolve(outcomeOf(inspected.receipt));
+                                continue;
+                            }
+                            const admission = await authorizeCatalogOperation(this.conn, this.operationRuntime, operation, resolved);
+                            const decision = this.claimInvocationReceipt(prepared);
+                            if (decision._tag === "Conflict" ||
+                                decision._tag === "OperationChanged" ||
+                                decision._tag === "UpdateRequired") {
+                                this.stats.rejected++;
+                                p.resolve({ _tag: decision._tag });
+                                continue;
+                            }
+                            if (decision._tag === "Replay" || decision._tag === "Recover") {
+                                if (!this.replayableMappings(decision.receipt, sealingContext)) {
+                                    await resolveCompatibility("UpdateRequired");
+                                    continue;
+                                }
+                                if (decision.receipt.status === "completed") {
+                                    await authorizeCatalogOperationReplay(this.conn, this.operationRuntime, operation, decision.receipt.replayFence, resolved);
+                                }
+                                p.resolve(outcomeOf(decision.receipt));
+                                continue;
+                            }
+                            claim = decision.receipt;
+                            await this.boundaries.checkpoint("operation.claimed");
+                            const executed = await executeCatalogOperation(this.conn, this.operationRuntime, operation, resolved, admission, sealingContext?.sealing);
+                            const rep = executed.report;
+                            const event = {
+                                _tag: "Complete",
+                                committedT: rep.t,
+                                output: executed.output,
+                                replayFence: executed.replayFence,
+                                ...(sealingContext === undefined ||
+                                    executed.allocations.length === 0
+                                    ? {}
+                                    : {
+                                        allocations: {
+                                            version: 1,
+                                            keyId: sealingContext.sealing.keyId,
+                                            scope: { ...sealingContext.scope },
+                                            entries: executed.allocations,
+                                        },
+                                    }),
+                            };
+                            const terminal = transitionInvocationReceipt(claim, event);
+                            const txInstant = rep.txData[0]?.v;
+                            entries.push({ t: rep.t, txInstant, datoms: rep.txData });
+                            acks.push({
+                                p,
+                                ack: outcomeOf(terminal),
+                                assertFresh: executed.assertFresh,
+                                receiptCompletion: { claim, event },
+                            });
+                        }
+                        catch (err) {
+                            if (err instanceof OperationRuntimeFault) {
+                                this.log.error("operation.failed", {
+                                    stage: err.stage,
+                                    error: err.detail instanceof Error
+                                        ? err.detail.message
+                                        : String(err.detail),
+                                });
+                            }
+                            if (claim !== undefined) {
+                                try {
+                                    const terminal = this.finishInvocationReceipt(claim, this.invocationFailureEvent(err));
+                                    this.stats.rejected++;
+                                    this.log.warn("operation.rejected", {
+                                        status: terminal.status,
+                                    });
+                                    p.resolve(invocationReceiptOutcome(terminal));
+                                }
+                                catch (storageError) {
+                                    this.die(`receipt write failed: ${storageError instanceof Error ? storageError.message : String(storageError)}`, storageError, [p]);
+                                    return;
+                                }
+                            }
+                            else {
+                                const e = this.scrub(err, p);
+                                this.stats.rejected++;
+                                this.log.warn("tx.rejected", {
+                                    code: e?.code,
+                                    error: e instanceof Error ? e.message : String(e),
+                                });
+                                p.reject(e);
+                            }
+                        }
+                        continue;
+                    }
+                    if (p.clientTxId !== undefined) {
+                        const key = clientTxReplayKey(p.principal, p.clientTxId);
+                        const hit = this.recentAcks.get(key) ?? batchAcks.get(key);
+                        if (hit) {
+                            p.resolve(hit);
+                            continue;
+                        }
+                    }
+                    try {
+                        if (!p.system)
+                            await this.applyProvision(p, entries);
+                        const tx = await this.authorize(p);
+                        const rep = await this.conn.transact(tx);
+                        const ack = {
+                            t: rep.t,
+                            txEid: rep.txEid,
+                            tempids: rep.tempids,
+                            datoms: await this.ackDatoms(rep.txData, p.principal),
+                            ...(p.clientTxId !== undefined ? { clientTxId: p.clientTxId } : {}),
+                        };
+                        const txInstant = rep.txData[0]?.v;
+                        entries.push({ t: rep.t, txInstant, datoms: rep.txData });
+                        if (p.clientTxId !== undefined) {
+                            batchAcks.set(clientTxReplayKey(p.principal, p.clientTxId), ack);
+                        }
+                        acks.push({ p, ack });
+                    }
+                    catch (err) {
+                        if (err instanceof OperationRuntimeFault) {
+                            this.log.error("operation.failed", {
+                                stage: err.stage,
+                                error: err.detail instanceof Error ? err.detail.message : String(err.detail),
+                            });
+                        }
+                        const e = this.scrub(err, p);
+                        this.stats.rejected++;
+                        this.log.warn("tx.rejected", { code: e?.code, error: e instanceof Error ? e.message : String(e) });
+                        p.reject(e);
+                    }
+                }
+                if (fences)
+                    await yieldToEventLoop();
+                const resolveMs = performance.now() - tResolve;
+                this.stats.resolveMs += resolveMs;
+                if (entries.length === 0)
+                    continue;
+                const tWrite = performance.now();
+                try {
+                    await this.boundaries.checkpoint("transactor.commit");
+                    for (const pending of acks)
+                        pending.assertFresh?.();
+                    this.host.transactionSync(() => {
+                        this.boundaries.checkpointSync("transactor.commit.write");
+                        for (const e of entries)
+                            this.appendLogRow(e);
+                        this.setMeta("next_eid", this.conn.nextEntityId);
+                        for (const pending of acks) {
+                            if (pending.receiptCompletion !== undefined) {
+                                this.finishInvocationReceipt(pending.receiptCompletion.claim, pending.receiptCompletion.event, true);
+                            }
+                        }
+                    });
+                }
+                catch (err) {
+                    this.die(`log write failed: ${err instanceof Error ? err.message : String(err)}`, err, acks.map((a) => a.p));
+                    return;
+                }
+                if (fences)
+                    await yieldToEventLoop();
+                const writeMs = performance.now() - tWrite;
+                this.stats.commitMs += writeMs;
+                this.stats.txs += entries.length;
+                this.stats.batches++;
+                if (entries.length > this.stats.maxBatch)
+                    this.stats.maxBatch = entries.length;
+                this.txSinceIndex += entries.length;
+                this.txRate.mark(entries.length, this.host.now());
+                this.batchSizes.observe(entries.length);
+                this.commitLatency.observe(writeMs);
+                this.resolveLatency.observe(resolveMs);
+                this.log.debug("tx.commit", { t: this.conn.t, batch: entries.length, datoms: entries.reduce((n, e) => n + e.datoms.length, 0), writeMs: round(writeMs), queued: this.queue.length, txsSinceIndex: this.txSinceIndex });
+                for (const [id, ack] of batchAcks)
+                    this.rememberAck(id, ack);
+                for (const a of acks) {
+                    try {
+                        a.assertFresh?.();
+                        a.p.resolve(a.ack);
+                    }
+                    catch (err) {
+                        this.stats.rejected++;
+                        a.p.reject(err);
+                    }
+                }
+                const loopMs = performance.now() - tLoop;
+                this.stats.loopMs += loopMs;
+                this.loopLatency.observe(loopMs);
+                this.metrics.batch({
+                    db: safeName(this.host) ?? "unknown",
+                    resolveMs,
+                    commitMs: writeMs,
+                    batchSize: entries.length,
+                    queueDepth,
+                    noveltyDatoms: this.conn.noveltyCount,
+                    fenceMs,
+                    txOk: entries.length,
+                    txErr: batch.length - entries.length,
+                });
+                for (const e of entries)
+                    this.broadcast(txFrame(e));
+                await this.indexer.maybeSchedule();
+            }
+        }
+        catch (err) {
+            this.die(`commit loop failed: ${err instanceof Error ? err.message : String(err)}`, err, []);
+        }
+        finally {
+            this.committing = false;
+            if (this.queue.length > 0 && this.dead === undefined) {
+                this.committing = true;
+                void this.commitLoop();
+            }
+        }
+    }
+    async applyProvision(_p, _entries) {
+        return;
+    }
+    async authorize(p) {
+        return p.tx;
+    }
+    async ackDatoms(datoms, _principal) {
+        return datoms.map(toWireDatom);
+    }
+    scrub(err, _p) {
+        return err;
+    }
+    die(reason, cause, inflight) {
+        if (this.dead !== undefined)
+            return;
+        this.dead = reason;
+        this.log.error("tx.aborted", { reason, inflight: inflight.length, queued: this.queue.length, t: this.conn?.t });
+        const err = cause instanceof Error ? cause : new TransactorDeadError(reason);
+        for (const p of inflight)
+            p.reject(err);
+        for (const p of this.queue)
+            p.reject(new TransactorDeadError(reason));
+        this.queue = [];
+        this.host.abort(reason);
+    }
+    broadcast(frame) {
+        this.proposalHandler?.notify();
+        const msg = JSON.stringify(frame);
+        this.stats.broadcasts++;
+        for (const ws of this.host.sockets()) {
+            try {
+                ws.send(msg);
+            }
+            catch {
+            }
+        }
+    }
+    onSubscribe(ws, from) {
+        ws.send(JSON.stringify({ v: 1, kind: "hello", t: this.conn.t, root: this.rootRecord }));
+        this.sendCatchUp(ws, Number.isFinite(from) ? from : 0);
+        this.log.info("subscriber.connect", { from, t: this.conn.t, subscribers: this.host.sockets().length });
+    }
+    onSocketMessage(ws, message) {
+        if (typeof message !== "string")
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(message);
+        }
+        catch {
+            return;
+        }
+        if (msg?.kind === "resume" && typeof msg.from === "number")
+            this.sendCatchUp(ws, msg.from);
+        else if (msg?.kind === "ping")
+            ws.send(JSON.stringify({ v: 1, kind: "pong", t: this.conn.t }));
+    }
+    sendCatchUp(ws, from) {
+        const t = this.conn.t;
+        if (from >= t)
+            return;
+        const earliest = this.earliestLogT();
+        if (earliest === 0 || earliest > from + 1) {
+            ws.send(JSON.stringify({ v: 1, kind: "gap", from: Math.max(from, earliest - 1) }));
+            this.log.warn("subscriber.gap", { from, earliestLogT: earliest, t });
+            from = Math.max(from, earliest - 1);
+        }
+        for (const e of this.readLogEntries(from, t))
+            ws.send(JSON.stringify(txFrame(e)));
+    }
+    alarmQueue = Promise.resolve();
+    scheduleAlarm(deadline) {
+        const next = this.alarmQueue.then(async () => {
+            const existing = await this.host.getAlarm();
+            if (existing === null || deadline < existing)
+                await this.host.setAlarm(deadline);
+        });
+        this.alarmQueue = next.catch(() => { });
+        return next;
+    }
+    async onAlarm() {
+        await this.init();
+        await this.serialized(async () => this.proposalService.expire(this.host.now()));
+        await this.indexer.onAlarm();
+        await this.proposalService.schedule();
+    }
+    info() {
+        return {
+            t: this.conn.t,
+            root: this.rootRecord,
+            novelty: this.conn.noveltyCount,
+            txsSinceIndex: this.txSinceIndex,
+            logWatermark: this.logWatermark,
+            earliestLogT: this.earliestLogT(),
+            nextEid: this.conn.nextEntityId,
+            subscribers: this.host.sockets().length,
+            opts: { timingYields: this.host.config.timingYields, maxBatch: this.host.config.maxBatch },
+            stats: this.stats,
+            metrics: {
+                txPerSec: round(this.txRate.rate(this.host.now())),
+                batchSize: this.batchSizes.snapshot(),
+                commitMs: this.commitLatency.snapshot(),
+                avgBatch: this.stats.batches ? round(this.stats.txs / this.stats.batches) : 0,
+                resolveMs: round(this.stats.resolveMs),
+                loopMs: round(this.stats.loopMs),
+                batchResolveMs: this.resolveLatency.snapshot(),
+                batchCommitMs: this.commitLatency.snapshot(),
+                batchLoopMs: this.loopLatency.snapshot(),
+                fenceMs: this.fenceLatency.snapshot(),
+                noveltyDatoms: this.conn.noveltyCount,
+                queueDepth: this.queue.length,
+                ...this.metrics.snapshot(),
+            },
+            store: this.store.stats,
+            indexer: this.indexer.status(),
+        };
+    }
+    operationReceiptCount() {
+        const row = this.host.sql.exec(`SELECT COUNT(*) AS count FROM operation_receipts`).toArray()[0];
+        return Number(row?.count ?? 0);
+    }
+    async handleRequest(request) {
+        await this.init();
+        this.metrics.observeColo(request.cf?.colo ?? request.headers.get("x-ramose-colo") ?? undefined);
+        const url = new URL(request.url);
+        return Effect.runPromise(Effect.tryPromise({ try: () => this.route(request, url), catch: toHttpError }).pipe(Effect.catchTags({
+            TxRejected: (e) => Effect.sync(() => errorResponse(e)),
+            Unauthorized: (e) => Effect.sync(() => errorResponse(e)),
+            OperationRejected: (e) => Effect.sync(() => errorResponse(e)),
+            TransactorDead: (e) => Effect.sync(() => errorResponse(e)),
+            Unavailable: (e) => Effect.sync(() => errorResponse(e)),
+            BadRequest: (e) => Effect.sync(() => errorResponse(e)),
+            NotFound: (e) => Effect.sync(() => errorResponse(e)),
+            Internal: (e) => Effect.sync(() => errorResponse(e)),
+        })));
+    }
+    async route(request, url) {
+        const path = url.pathname;
+        if (path === "/changesets" && request.method === "POST") {
+            let command;
+            try {
+                command = decodeChangesetCommand(await request.json());
+            }
+            catch {
+                throw new BadRequest({ message: "invalid changeset command" });
+            }
+            return json(await this.changeset(command));
+        }
+        if (path === "/invoke" && request.method === "POST") {
+            const body = await request.json();
+            const raw = body?.invocation;
+            const invocation = typeof raw === "object" && raw !== null && !Array.isArray(raw)
+                ? {
+                    ...raw,
+                    ...(Object.hasOwn(raw, "target")
+                        ? { target: fromJson(raw.target) }
+                        : {}),
+                }
+                : undefined;
+            if (invocation === undefined || invocation.database !== safeName(this.host)) {
+                throw new BadRequest({ message: "invalid deployed operation invocation" });
+            }
+            const entityIdScope = parseEntityIdScope(invocation.entityIdScope);
+            const allocations = parseInvocationAllocations(invocation.allocations);
+            if (allocations === undefined ||
+                (invocation.sealedTarget !== undefined &&
+                    (typeof invocation.sealedTarget !== "string" ||
+                        entityIdScope === undefined)) ||
+                (allocations.length > 0 && entityIdScope === undefined)) {
+                throw new BadRequest({ message: "invalid deployed operation invocation" });
+            }
+            if (entityIdScope !== undefined &&
+                (typeof invocation.entityIdKeyId !== "string" ||
+                    invocation.entityIdKeyId.length === 0)) {
+                throw new BadRequest({ message: "invalid deployed operation invocation" });
+            }
+            const resolved = {
+                ...invocation,
+                ...(entityIdScope === undefined ? {} : { entityIdScope }),
+                ...(allocations.length === 0 ? {} : { allocations }),
+            };
+            return new Response(JSON.stringify(await this.invoke(resolved)), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        if (path === "/transact" && request.method === "POST") {
+            const body = fromJson(await request.json());
+            if (!body || !Array.isArray(body.tx))
+                throw new BadRequest({ message: "body must be { tx: [...] }" });
+            const clientTxId = typeof body.clientTxId === "string" && body.clientTxId.length > 0 ? body.clientTxId : undefined;
+            const ack = await this.transact(body.tx, asPrincipal(body.principal), clientTxId);
+            return json(ack);
+        }
+        if (path === "/provision" && request.method === "POST") {
+            const body = fromJson(await request.json());
+            return json(await this.provision(asPrincipal(body?.principal)));
+        }
+        if (path === "/info")
+            return json(this.info());
+        if (path === "/log") {
+            const from = Number(url.searchParams.get("from") ?? "0");
+            const to = Number(url.searchParams.get("to") ?? String(Number.MAX_SAFE_INTEGER));
+            const entries = this.readLogEntries(from, to, 10_000);
+            const frames = entries.map(txFrame);
+            return json({ from, to, earliestLogT: this.earliestLogT(), t: this.conn.t, entries: frames });
+        }
+        if (path === "/admin/index" && request.method === "POST")
+            return json(await this.indexer.runNow());
+        if (path === "/admin/gc" && request.method === "POST")
+            return json(await this.indexer.gcNow());
+        throw new NotFound({ message: "not found" });
+    }
+}
+//# sourceMappingURL=transactor.js.map