@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance.js

@@ -0,0 +1,364 @@
+import { Effect, Layer, Logger, ManagedRuntime, Option } from "effect";
+import { constVoid } from "effect/Function";
+import { Statement } from "effect/sql";
+import { User } from "../index.js";
+import { principal } from "../identity/caller.js";
+import { ContentHooks, TurnHooks, } from "../runtime/turn/hooks.js";
+import { NekiTurnSessions } from "../runtime/database/neki/session.js";
+import { ActorTest } from "./actor-test.js";
+import { accessConformance, accessSuite } from "./conformance/access.js";
+import { admissionConformance, admissionSuite } from "./conformance/admission.js";
+import { adoptionConformance } from "./conformance/adoption.js";
+import { assertionsConformance, assertionsSuite, edgeConformance, } from "./conformance/assertions.js";
+import { batchesConformance, batchesSuite } from "./conformance/batches.js";
+import { blobsConformance, blobsSuite } from "./conformance/blobs.js";
+import { capacityConformance } from "./conformance/capacity.js";
+import { clientConformance, clientSuite } from "./conformance/client.js";
+import { coldServeConformance, coldServeEdgeConformance, coldServeSuite, } from "./conformance/cold-serve.js";
+import { connectionsConformance } from "./conformance/connections.js";
+import { connectionsSuite } from "./conformance/connections/actors.js";
+import { contentConformance, contentSuite } from "./conformance/content-blobs.js";
+import { counterConformance, counterSuite } from "./conformance/counter.js";
+import { cronClusterConformance, cronConformance } from "./conformance/cron.js";
+import { drainConformance, drainSuite } from "./conformance/drain.js";
+import { effectControlClusterConformance, effectControlConformance, effectControlSuite, } from "./conformance/effect-control.js";
+import { effectsConformance, effectsSuite } from "./conformance/effects.js";
+import { eventsConformance, eventsSuite } from "./conformance/events.js";
+import { exportConformance } from "./conformance/export.js";
+import { fleetConformance, fleetSuite } from "./conformance/fleet.js";
+import { heapConformance } from "./conformance/heap.js";
+import { httpConformance, httpSuite } from "./conformance/http.js";
+import { inspectionViewsConformance, inspectionViewsSuite } from "./conformance/inspection-views.js";
+import { inspectorConformance, inspectorSuite } from "./conformance/inspector.js";
+import { mintConformance, mintSuite } from "./conformance/mint.js";
+import { multiRunnerConformance } from "./conformance/multi-runner.js";
+import { observabilityConformance } from "./conformance/observability.js";
+import { offlineConformance, offlineSuite } from "./conformance/offline.js";
+import { operatorConformance } from "./conformance/operator.js";
+import { crossShardOutboxConformance, crossShardSuite } from "./conformance/outbox-cross-shard.js";
+import { outboxConformance, outboxSuite } from "./conformance/outbox.js";
+import { payloadMigrationsConformance } from "./conformance/payload-migrations.js";
+import { pipelineConformance } from "./conformance/pipeline.js";
+import { groupsConformance } from "./conformance/groups.js";
+import { placementConformance, placementSuite } from "./conformance/placement.js";
+import { progressConformance, progressDeliveryConformance, progressSuite, } from "./conformance/progress.js";
+import { propertiesConformance, propertiesSuite } from "./conformance/properties.js";
+import { protocolsConformance, protocolsSuite } from "./conformance/protocols.js";
+import { readYourWritesConformance, readYourWritesSuite } from "./conformance/read-your-writes.js";
+import { reducerConformance, reducerSuite } from "./conformance/reducers.js";
+import { relayClusterConformance, relayConformance, relaySuite } from "./conformance/relay.js";
+import { restoreConformance, restoreSuite } from "./conformance/restore.js";
+import { retentionConformance, retentionSuite } from "./conformance/retention.js";
+import { rlsConformance } from "./conformance/rls.js";
+import { simulationConformance } from "./conformance/simulation.js";
+import { singleShardConformance } from "./conformance/single-shard.js";
+import { singletonConformance } from "./conformance/singleton.js";
+import { streamsConformance, streamsSuite } from "./conformance/streams.js";
+import { subscriptionsConformance } from "./conformance/subscriptions.js";
+import { subscriptionsSuite } from "./conformance/subscriptions/actors.js";
+import { subscriptionsClusterConformance } from "./conformance/subscriptions/cluster.js";
+import { subscriptionsRetentionConformance } from "./conformance/subscriptions/retention.js";
+import { tablesConformance, tablesSuite } from "./conformance/tables.js";
+import { transportsConformance } from "./conformance/transports.js";
+import { transportsSuite } from "./conformance/transports/actors.js";
+import { watchConformance, watchSuite } from "./conformance/watch.js";
+import { workflowVersionsConformance } from "./conformance/workflow-versions.js";
+import { workflowsConformance } from "./conformance/workflows.js";
+import { workflowsSuite } from "./conformance/workflows/actors.js";
+import { foundationConformance, foundationSuite } from "./foundation.js";
+const group = (suite, cases, requires) => ({
+    suite,
+    cases: requires === undefined ? cases : cases.map((each) => ({ ...each, ...requires })),
+});
+/** Every case of the group opens a fresh database or a snapshot. */
+const freshDatabases = { requiresFreshDatabase: true };
+/** Cases whose own actors, if any, they build into their own runtimes or clusters. */
+const standalone = {};
+/**
+ * Every suite in the registry. The single-shard case checks the routing of
+ * every statement the framework issues, so it needs every feature's actors
+ * registered, as a deployment of all of them would.
+ */
+const everySuite = {
+    get uses() {
+        return [...new Set(allGroups.map((group) => conformanceGroups[group].suite))].filter((suite) => suite !== everySuite);
+    },
+};
+/**
+ * Every conformance case, grouped by the file that owns it, with the suite
+ * that owns its actors. `describeConformance` runs a subset through `groups`,
+ * so a group can run in its own Vitest file and worker; `conformance` is
+ * their union and the order within a group is kept.
+ */
+export const conformanceGroups = {
+    foundation: group(foundationSuite, foundationConformance),
+    access: group(accessSuite, accessConformance, freshDatabases),
+    admission: group(admissionSuite, admissionConformance),
+    http: group(httpSuite, httpConformance),
+    protocols: group(protocolsSuite, protocolsConformance),
+    assertions: group(assertionsSuite, assertionsConformance),
+    edge: group(assertionsSuite, edgeConformance),
+    coldServeEdge: group(coldServeSuite, coldServeEdgeConformance),
+    client: group(clientSuite, clientConformance),
+    offline: group(offlineSuite, offlineConformance),
+    capacity: group(standalone, capacityConformance, freshDatabases),
+    heap: group(standalone, heapConformance, freshDatabases),
+    events: group(eventsSuite, eventsConformance),
+    reducer: group(reducerSuite, reducerConformance),
+    outbox: group(outboxSuite, outboxConformance),
+    tables: group(tablesSuite, tablesConformance),
+    effects: group(effectsSuite, effectsConformance),
+    progress: group(progressSuite, progressConformance),
+    multiRunner: group(standalone, multiRunnerConformance, freshDatabases),
+    simulation: group(standalone, simulationConformance, freshDatabases),
+    drain: group(drainSuite, drainConformance),
+    pipeline: group(standalone, pipelineConformance, freshDatabases),
+    batches: group(batchesSuite, batchesConformance),
+    groups: group(standalone, groupsConformance, freshDatabases),
+    relay: group(relaySuite, relayConformance),
+    relayCluster: group(relaySuite, relayClusterConformance, freshDatabases),
+    effectControl: group(effectControlSuite, effectControlConformance),
+    effectControlCluster: group(effectControlSuite, effectControlClusterConformance),
+    singleton: group(standalone, singletonConformance, freshDatabases),
+    cron: group(standalone, cronConformance, freshDatabases),
+    cronCluster: group(standalone, cronClusterConformance, freshDatabases),
+    blobs: group(blobsSuite, blobsConformance),
+    inspectionViews: group(inspectionViewsSuite, inspectionViewsConformance),
+    inspector: group(inspectorSuite, inspectorConformance),
+    rls: group(standalone, rlsConformance, freshDatabases),
+    retention: group(retentionSuite, retentionConformance),
+    restore: group(restoreSuite, restoreConformance, freshDatabases),
+    workflows: group(workflowsSuite, workflowsConformance),
+    connections: group(connectionsSuite, connectionsConformance),
+    streams: group(streamsSuite, streamsConformance),
+    progressDelivery: group(progressSuite, progressDeliveryConformance),
+    transports: group(transportsSuite, transportsConformance),
+    workflowVersions: group(standalone, workflowVersionsConformance, freshDatabases),
+    payloadMigrations: group(standalone, payloadMigrationsConformance, freshDatabases),
+    subscriptions: group(subscriptionsSuite, subscriptionsConformance),
+    subscriptionsRetention: group(subscriptionsSuite, subscriptionsRetentionConformance),
+    subscriptionsCluster: group(subscriptionsSuite, subscriptionsClusterConformance, freshDatabases),
+    content: group(contentSuite, contentConformance),
+    counter: group(counterSuite, counterConformance),
+    properties: group(propertiesSuite, propertiesConformance),
+    mint: group(mintSuite, mintConformance),
+    readYourWrites: group(readYourWritesSuite, readYourWritesConformance),
+    observability: group(standalone, observabilityConformance, freshDatabases),
+    operator: group(standalone, operatorConformance, freshDatabases),
+    export: group(standalone, exportConformance, freshDatabases),
+    coldServe: group(coldServeSuite, coldServeConformance),
+    placement: group(placementSuite, placementConformance),
+    watch: group(watchSuite, watchConformance),
+    adoption: group(standalone, adoptionConformance),
+    singleShard: group(everySuite, singleShardConformance),
+    crossShardOutbox: group(crossShardSuite, crossShardOutboxConformance),
+    fleet: group(fleetSuite, fleetConformance),
+};
+const allGroups = Object.keys(conformanceGroups);
+/**
+ * The shared durable-turn conformance cases. Cases flagged
+ * `requiresIndependentConnections` need real Postgres: a second database
+ * connection to read committed state while a turn holds its transaction open
+ * or to take a competing row lock, or a database outside the JavaScript heap
+ * they measure. They never run on single-connection backends such as PGlite.
+ */
+export const conformance = allGroups.flatMap((name) => conformanceGroups[name].cases);
+/** The capabilities `conformanceCase` requires, in a fixed order. */
+export const requirementsOf = (conformanceCase) => [
+    ...(conformanceCase.requiresIndependentConnections === true
+        ? ["independentConnections"]
+        : []),
+    ...(conformanceCase.requiresReplica === true ? ["replica"] : []),
+    ...(conformanceCase.requiresEdge === true ? ["edge"] : []),
+    ...(conformanceCase.requiresNeki === true ? ["neki"] : []),
+    ...(conformanceCase.requiresLogicalDecoding === true ? ["logicalDecoding"] : []),
+    ...(conformanceCase.requiresFreshDatabase === true ? ["freshDatabase"] : []),
+];
+/** The capabilities `backend` provides. */
+export const capabilitiesOf = (backend) => new Set([
+    ...(backend.independentConnections ? ["independentConnections"] : []),
+    ...(backend.hasReplica === true ? ["replica"] : []),
+    ...(backend.edge === undefined ? [] : ["edge"]),
+    ...(backend.neki === true ? ["neki"] : []),
+    ...(backend.logicalDecoding === true ? ["logicalDecoding"] : []),
+    ...(backend.freshDatabases ? ["freshDatabase"] : []),
+]);
+/** `suites` and every suite they use, each once, dependencies first. */
+const withDependencies = (suites) => {
+    const ordered = [];
+    const visit = (suite) => {
+        if (ordered.includes(suite))
+            return;
+        for (const used of suite.uses ?? [])
+            visit(used);
+        ordered.push(suite);
+    };
+    for (const suite of suites)
+        visit(suite);
+    return ordered;
+};
+/**
+ * Registers the named groups' cases, or every group's, against `backend`.
+ * Only the selected groups' suites, and the suites they use, build their
+ * actors and fixtures. The same case names run on every backend; a case
+ * whose requirements the backend lacks is reported through `registrar.skip`.
+ *
+ * Each case runs under the registrar's abort signal: a timed-out or
+ * cancelled case is interrupted, its finalizers run, and the next case waits
+ * for them, then restarts a runtime the case left stopped and starts with
+ * open test authorization.
+ */
+export const describeConformance = (options) => registerConformance({
+    ...options,
+    selected: (options.groups ?? allGroups).map((group) => conformanceGroups[group]),
+});
+/** How long the next case waits for an interrupted case's finalizers before it starts anyway. */
+const SETTLE_TIMEOUT = "20 seconds";
+/** Registers `selected` groups; `describeConformance` passes registry groups, tests pass their own. */
+export const registerConformance = (options) => {
+    const { name, backend, registrar, selected } = options;
+    const suites = withDependencies(selected.map(({ suite }) => suite));
+    const fixtures = new Map(suites.map((suite) => [suite, suite.fixture?.()]));
+    const fixtureOf = (suite) => {
+        if (!fixtures.has(suite))
+            throw new Error("A conformance case read the fixture of a suite its own suite does not use");
+        return fixtures.get(suite);
+    };
+    const access = { allowed: true, denied: new Set(), revoked: new Set() };
+    const turnHooks = suites.flatMap((suite) => suite.turn?.(fixtureOf(suite)) ?? []);
+    const contentHooks = suites.flatMap((suite) => suite.content?.(fixtureOf(suite)) ?? []);
+    const loggers = suites.flatMap((suite) => suite.logger?.(fixtureOf(suite)) ?? []);
+    let live = Layer.empty;
+    for (const suite of suites)
+        if (suite.layer !== undefined)
+            live = Layer.merge(live, suite.layer(fixtureOf(suite)));
+    const capabilities = capabilitiesOf(backend);
+    let store;
+    let current;
+    const opened = () => {
+        if (store === undefined)
+            throw new Error("Conformance environment is not open");
+        return store;
+    };
+    const environment = {
+        run: (effect) => {
+            if (current === undefined)
+                return Promise.reject(new Error("Conformance environment is stopped"));
+            return current.runPromise(Effect.scoped(effect));
+        },
+        build: (overrides) => ManagedRuntime.make(live.pipe(Layer.provideMerge(ActorTest.layer({
+            database: overrides?.database ?? opened().database,
+            maxConnections: 6,
+            admission: overrides?.admission,
+            replica: overrides?.replica,
+            as: User.make({ subject: "alice" }),
+            authorize: (request) => Effect.sync(() => access.allowed &&
+                !access.denied.has(request.command) &&
+                Option.match(principal(request.caller), {
+                    onNone: () => true,
+                    onSome: ({ subject }) => !access.revoked.has(subject),
+                })),
+            retryWindowMs: overrides?.retryWindowMs ?? 60_000,
+            content: overrides?.content,
+        }).pipe(Layer.provide(Layer.mergeAll(Layer.succeed(TurnHooks, {
+            at: (point, request) => Effect.forEach(turnHooks, (hook) => hook(point, request), { discard: true }),
+        }), Layer.succeed(ContentHooks, {
+            at: (point) => Effect.forEach(contentHooks, (hook) => hook(point), { discard: true }),
+        }), Layer.succeed(NekiTurnSessions, backend.neki === true), overrides?.observe === undefined
+            ? Layer.empty
+            : Layer.succeed(Statement.CurrentTransformer, (statement) => Effect.sync(() => {
+                overrides.observe(statement);
+                return statement;
+            })))))), Layer.provideMerge(backend.services), Layer.provide(Logger.layer(loggers, { mergeWithExisting: true })), Layer.orDie)),
+        stop: Effect.suspend(() => {
+            const previous = current;
+            current = undefined;
+            return previous === undefined ? Effect.void : Effect.promise(() => previous.dispose());
+        }),
+        restart: Effect.suspend(() => Effect.andThen(environment.stop, () => Effect.promise(() => {
+            current = environment.build();
+            return current.runPromise(Effect.void);
+        }))),
+        freshDatabase: Effect.suspend(() => opened().freshDatabase),
+        snapshot: Effect.suspend(() => {
+            if (current !== undefined)
+                return Effect.die(new Error("A snapshot needs the conformance runtime stopped"));
+            return opened().copy(opened().database);
+        }),
+        get connect() {
+            return store?.connect;
+        },
+        get replica() {
+            return store?.replica;
+        },
+        httpServer: backend.httpServer,
+        get edge() {
+            return backend.edge;
+        },
+    };
+    /** The environment one case sees: its runs end with its signal, and only a declared case opens databases. */
+    const environmentFor = (conformanceCase, signal) => {
+        const undeclared = Effect.die(new Error(`Conformance case "${conformanceCase.name}" opens a fresh database or snapshot without declaring requiresFreshDatabase`));
+        return {
+            run: (effect) => {
+                if (current === undefined)
+                    return Promise.reject(new Error("Conformance environment is stopped"));
+                return current.runPromise(Effect.scoped(effect), { signal });
+            },
+            build: environment.build,
+            stop: environment.stop,
+            restart: environment.restart,
+            freshDatabase: conformanceCase.requiresFreshDatabase === true ? environment.freshDatabase : undeclared,
+            snapshot: conformanceCase.requiresFreshDatabase === true ? environment.snapshot : undeclared,
+            get connect() {
+                return environment.connect;
+            },
+            get replica() {
+                return environment.replica;
+            },
+            httpServer: environment.httpServer,
+            get edge() {
+                return environment.edge;
+            },
+        };
+    };
+    let previousCase = Promise.resolve();
+    registrar.describe(name, () => {
+        registrar.beforeAll(() => Effect.runPromise(Effect.gen(function* () {
+            store = yield* Effect.promise(() => backend.open());
+            yield* environment.restart;
+        })), 30_000);
+        registrar.afterAll(() => previousCase.then(constVoid, constVoid).then(() => Effect.runPromise(Effect.gen(function* () {
+            yield* environment.stop;
+            if (store !== undefined)
+                yield* store.close;
+            store = undefined;
+        }))));
+        for (const { suite, cases } of selected)
+            for (const conformanceCase of cases) {
+                if (requirementsOf(conformanceCase).some((required) => !capabilities.has(required))) {
+                    registrar.skip(conformanceCase.name);
+                    continue;
+                }
+                registrar.it(conformanceCase.name, ({ signal }) => {
+                    const settled = Effect.runPromise(Effect.promise(() => previousCase.then(constVoid, constVoid)).pipe(Effect.timeoutOption(SETTLE_TIMEOUT)));
+                    const running = settled
+                        .then(() => {
+                        access.allowed = true;
+                        access.denied.clear();
+                        access.revoked.clear();
+                        return Effect.runPromise(Effect.suspend(() => (current === undefined ? environment.restart : Effect.void)));
+                    })
+                        .then(() => conformanceCase.run({
+                        expect: registrar.expect,
+                        environment: environmentFor(conformanceCase, signal),
+                        fixture: fixtureOf(suite),
+                        access,
+                        fixtureOf,
+                    }));
+                    previousCase = running;
+                    return running;
+                }, conformanceCase.timeoutMs);
+            }
+    });
+};

package/dist/testing/database.d.ts

@@ -0,0 +1,31 @@
+import { Config, Crypto, Effect, Redacted, type Scope } from "effect";
+/**
+ * A name for a test database that carries its creation time, so a later run
+ * on a shared server can tell a leftover from a live run's database.
+ */
+export declare const databaseName: (crypto: Crypto.Crypto, prefix: "actors" | "actors_template" | "disposable" | "isolated" | "restored") => Effect.Effect<string, never, never>;
+/**
+ * Creates a database on the Postgres server `url` names for the current
+ * scope and drops it, ending its sessions, when the scope closes. With
+ * `template` the database is a copy of that one. Postgres refuses to copy a
+ * database while a session is open on it, and a closed pool's server
+ * sessions outlive it briefly, so a copy retries.
+ */
+export declare const disposableDatabase: (options: {
+    readonly url: Redacted.Redacted<string>;
+    readonly prefix?: "actors" | "actors_template" | "isolated" | "restored" | "disposable";
+    readonly template?: string | undefined;
+}) => Effect.Effect<Redacted.Redacted<string>, never, Crypto.Crypto | Scope.Scope>;
+/**
+ * Drops the test databases an earlier run left behind on the server `url`
+ * names: a run that was killed, or whose teardown timed out, never dropped
+ * its own.
+ */
+export declare const sweepStaleDatabases: (url: Redacted.Redacted<string>) => Effect.Effect<void, never, never>;
+/**
+ * The database a test that runs on both backends uses: `undefined`, a fresh
+ * in-memory PGlite for each `ActorTest.layer` build, when `TEST_BACKEND` is
+ * `pglite`, and otherwise a disposable database on the server
+ * `TEST_DATABASE_URL` names, dropped when the scope closes.
+ */
+export declare const testDatabase: Effect.Effect<Redacted.Redacted<string> | undefined, Config.ConfigError, Scope.Scope | Crypto.Crypto>;

package/dist/testing/database.js

@@ -0,0 +1,70 @@
+import { PgClient } from "@effect/sql-pg";
+import { Clock, Config, Context, Crypto, Effect, Layer, Redacted, Schedule, } from "effect";
+import { SqlClient } from "effect/sql";
+/** A test database older than this belongs to no live run: runs are cut off well before it. */
+const STALE_AFTER_MS = 60 * 60 * 1000;
+/** Test database names: a prefix, the creation time, and a random suffix. */
+const NAMED = /^(?:actors|actors_template|isolated|restored|disposable)_(\d{13})_[0-9a-f]{32}$/;
+/**
+ * A name for a test database that carries its creation time, so a later run
+ * on a shared server can tell a leftover from a live run's database.
+ */
+export const databaseName = Effect.fnUntraced(function* (crypto, prefix) {
+    const uuid = (yield* crypto.randomUUIDv4.pipe(Effect.orDie)).replaceAll("-", "");
+    return `${prefix}_${yield* Clock.currentTimeMillis}_${uuid}`;
+});
+/**
+ * Runs `use` on an administrative connection to the server `url` names that
+ * lives only as long as `use`. A connection held across a caller's scope
+ * would belong to the fiber that opened it, and a finalizer running after
+ * that fiber ended would find it interrupted.
+ */
+const withAdmin = (url, use) => Effect.scoped(Layer.build(PgClient.layer({ url, maxConnections: 1 })).pipe(Effect.map((context) => Context.get(context, SqlClient.SqlClient)), Effect.flatMap(use))).pipe(Effect.orDie);
+/** `url` with its database replaced by `name`. */
+const onDatabase = (url, name) => {
+    const database = new URL(Redacted.value(url));
+    database.pathname = `/${name}`;
+    return Redacted.make(database.href);
+};
+/**
+ * Creates a database on the Postgres server `url` names for the current
+ * scope and drops it, ending its sessions, when the scope closes. With
+ * `template` the database is a copy of that one. Postgres refuses to copy a
+ * database while a session is open on it, and a closed pool's server
+ * sessions outlive it briefly, so a copy retries.
+ */
+export const disposableDatabase = Effect.fnUntraced(function* (options) {
+    const name = yield* databaseName(yield* Crypto.Crypto, options.prefix ?? "disposable");
+    yield* Effect.acquireRelease(options.template === undefined
+        ? withAdmin(options.url, (admin) => admin.unsafe(`CREATE DATABASE "${name}"`))
+        : withAdmin(options.url, (admin) => admin
+            .unsafe(`CREATE DATABASE "${name}" TEMPLATE "${options.template}"`)
+            .pipe(Effect.retry({ times: 100, schedule: Schedule.spaced("50 millis") }))), () => withAdmin(options.url, (admin) => admin.unsafe(`DROP DATABASE IF EXISTS "${name}" WITH (FORCE)`)));
+    return onDatabase(options.url, name);
+});
+/**
+ * Drops the test databases an earlier run left behind on the server `url`
+ * names: a run that was killed, or whose teardown timed out, never dropped
+ * its own.
+ */
+export const sweepStaleDatabases = (url) => withAdmin(url, (admin) => Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const rows = yield* admin `SELECT datname FROM pg_database`;
+    yield* Effect.forEach(rows
+        .map(({ datname }) => datname)
+        .filter((name) => {
+        const created = NAMED.exec(name)?.[1];
+        return created !== undefined && now - Number(created) > STALE_AFTER_MS;
+    }), (name) => admin.unsafe(`DROP DATABASE IF EXISTS "${name}" WITH (FORCE)`), { concurrency: "unbounded", discard: true });
+}));
+/**
+ * The database a test that runs on both backends uses: `undefined`, a fresh
+ * in-memory PGlite for each `ActorTest.layer` build, when `TEST_BACKEND` is
+ * `pglite`, and otherwise a disposable database on the server
+ * `TEST_DATABASE_URL` names, dropped when the scope closes.
+ */
+export const testDatabase = Effect.gen(function* () {
+    if ((yield* Config.Literals(["pglite", "postgres"], "TEST_BACKEND")) === "pglite")
+        return undefined;
+    return yield* disposableDatabase({ url: yield* Config.Redacted("TEST_DATABASE_URL") });
+});

package/dist/testing/foundation.d.ts

@@ -0,0 +1,41 @@
+import { Effect, Layer, Logger } from "effect";
+import type { ConformanceCase } from "./conformance.ts";
+import type { ConformanceSuite } from "./conformance.ts";
+export interface RecordedDefect {
+    readonly actor: string;
+    readonly id: string;
+    readonly command: string;
+    readonly cause: string;
+}
+/** The annotations of a `Delivery timed out` warning. */
+export interface RecordedTimeout {
+    readonly actor: unknown;
+    readonly id: unknown;
+    readonly commandId: unknown;
+    readonly activation: unknown;
+    readonly turnSessions: unknown;
+    readonly restarting: unknown;
+}
+export interface FoundationFixture {
+    creates: number;
+    privateRuns: number;
+    slowIds: Array<string>;
+    slowFirst: Effect.Effect<void>;
+    deliveryRuns: number;
+    deliveryHold: Effect.Effect<void>;
+    defects: Array<RecordedDefect>;
+    /** Each `Delivery timed out` warning the runtime logged. */
+    timeouts: Array<RecordedTimeout>;
+}
+export declare const foundationFixture: () => FoundationFixture;
+/**
+ * Captures the runtime's deterministic-defect log records, which replace the
+ * removed defect hook, and the diagnostics of each delivery that timed out.
+ */
+export declare const defectRecorder: (fixture: FoundationFixture) => Logger.Logger<unknown, void>;
+/** Handlers for the foundation actors; `fixture` supplies the observable state cases assert on. */
+export declare const foundationLayer: (fixture: FoundationFixture) => Layer.Layer<never, never, import("./index.ts").InternalActors>;
+/** Identity, admission, receipts, state migration, and blob cases every backend must pass. A receipt retry may wait for PGlite's busy connection, so its delivery deadline covers that wait as well as the RPC reply. */
+export declare const foundationConformance: ReadonlyArray<ConformanceCase<FoundationFixture>>;
+/** Foundation actors; its logger records deterministic defects and delivery timeouts for the cases to read. */
+export declare const foundationSuite: ConformanceSuite<FoundationFixture>;