@nylorun/runtime 0.14.0-beta → 0.15.1-beta

package/dist/streams/relay/memory.js

@@ -1,176 +0,0 @@
-export class MemoryRecord {
-    /** `tenantId\0sessionId` → rows by seq. */
-    rows = new Map();
-    generations = new Map();
-    /** Committed transactions since the slot's confirmed position. */
-    retained = [];
-    lsn = 0;
-    slot;
-    reader;
-    /** Commits rows as one transaction (the record is written by the Session Store). */
-    commit(rows) {
-        if (rows.length === 0)
-            return;
-        for (const row of rows) {
-            const key = keyOf(row.tenantId, row.sessionId);
-            let list = this.rows.get(key);
-            if (!list)
-                this.rows.set(key, (list = []));
-            list[row.seq] = structuredClone(row);
-            if (!this.generations.has(row.tenantId))
-                this.generations.set(row.tenantId, row.generation);
-        }
-        this.lsn += 1;
-        const tx = { endLsn: lsnText(this.lsn), rows: rows.map((row) => structuredClone(row)) };
-        // A slot keeps what was committed after it was created.
-        if (this.slot)
-            this.retained.push({ lsn: this.lsn, tx });
-        this.reader?.deliver(tx);
-    }
-    /** Sets a Tenant's basin generation (a reset moves it on). */
-    setGeneration(tenantId, generation) {
-        this.generations.set(tenantId, generation);
-    }
-    /** Deletes a Tenant's rows, or one session's, as a reset or deletion does. */
-    deleteRows(tenantId, sessionId) {
-        for (const key of [...this.rows.keys()])
-            if (sessionId === undefined ? key.startsWith(`${tenantId}\u0000`) : key === keyOf(tenantId, sessionId))
-                this.rows.delete(key);
-    }
-    /** Forgets a Tenant (deletion). */
-    deleteTenant(tenantId) {
-        this.deleteRows(tenantId);
-        this.generations.delete(tenantId);
-    }
-    /** Drops the slot, as `max_slot_wal_keep_size` or an operator would. */
-    dropSlot() {
-        this.slot = undefined;
-        this.retained = [];
-        this.reader?.lost(new Error("replication slot dropped"));
-    }
-    /** Ends the reader's connection but keeps the slot, as a network failure would. */
-    disconnect() {
-        this.reader?.lost(new Error("replication connection lost"));
-    }
-    /** A change source over this record; one at a time holds the slot. */
-    source() {
-        return new MemoryChangeSource(this);
-    }
-    async readRange(tenantId, sessionId, from, to) {
-        const list = this.rows.get(keyOf(tenantId, sessionId)) ?? [];
-        return list.slice(from, to).filter(Boolean).map((row) => structuredClone(row));
-    }
-    async heads(after, limit) {
-        const heads = [];
-        for (const [key, list] of [...this.rows].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
-            const [tenantId, sessionId] = key.split("\u0000");
-            if (after && key <= keyOf(after.tenantId, after.sessionId))
-                continue;
-            const last = list[list.length - 1];
-            if (!last)
-                continue;
-            heads.push({ tenantId, sessionId, generation: last.generation, head: list.length });
-            if (heads.length >= limit)
-                break;
-        }
-        return heads;
-    }
-    async generation(tenantId) {
-        return this.generations.get(tenantId);
-    }
-    /** @internal */
-    attach(reader) {
-        if (this.reader && this.reader !== reader)
-            return undefined;
-        this.reader = reader;
-        if (!this.slot)
-            this.slot = { confirmed: this.lsn, reconcilePending: true };
-        return {
-            fresh: this.slot.reconcilePending,
-            replay: this.retained.map((entry) => entry.tx),
-        };
-    }
-    /** @internal */
-    detach(reader) {
-        if (this.reader === reader)
-            this.reader = undefined;
-    }
-    /** @internal */
-    reconciled() {
-        if (this.slot)
-            this.slot.reconcilePending = false;
-    }
-    /** @internal */
-    confirm(lsn) {
-        const position = Number(lsn.split("/")[1] ?? lsn);
-        if (!this.slot || position <= this.slot.confirmed)
-            return;
-        this.slot.confirmed = position;
-        this.retained = this.retained.filter((entry) => entry.lsn > position);
-    }
-    /** The slot's confirmed position (tests). */
-    confirmed() {
-        return this.slot?.confirmed;
-    }
-}
-class MemoryChangeSource {
-    record;
-    handlers;
-    timer;
-    active = false;
-    stopped = false;
-    constructor(record) {
-        this.record = record;
-    }
-    start(handlers) {
-        this.handlers = handlers;
-        this.tryAttach();
-    }
-    acknowledge(lsn) {
-        if (this.active)
-            this.record.confirm(lsn);
-    }
-    async reconciled() {
-        this.record.reconciled();
-    }
-    async stop() {
-        this.stopped = true;
-        clearTimeout(this.timer);
-        this.record.detach(this);
-        this.active = false;
-    }
-    /** @internal */
-    deliver(tx) {
-        if (this.active)
-            this.handlers?.onTx(tx);
-    }
-    /** @internal */
-    lost(error) {
-        if (!this.active)
-            return;
-        this.active = false;
-        this.record.detach(this);
-        this.handlers?.onInactive(error);
-        this.retry();
-    }
-    tryAttach() {
-        if (this.stopped)
-            return;
-        const attached = this.record.attach(this);
-        if (!attached)
-            return this.retry();
-        this.active = true;
-        this.handlers.onActive({ fresh: attached.fresh });
-        for (const tx of attached.replay)
-            this.handlers.onTx(tx);
-    }
-    retry() {
-        if (this.stopped)
-            return;
-        this.timer = setTimeout(() => this.tryAttach(), 20);
-        this.timer.unref?.();
-    }
-}
-const keyOf = (tenantId, sessionId) => `${tenantId}\u0000${sessionId}`;
-/** A Postgres-looking LSN, so positions read the same in logs. */
-const lsnText = (n) => `0/${n}`;

package/dist/tenant/envelope.d.ts

@@ -1,7 +0,0 @@
-import { type TenantEnvelope } from "@nylorun/core/contracts";
-export declare function parseEnvelope(raw: unknown, expectedId?: string): TenantEnvelope;
-export declare function envelopeNow(input: {
-    id: string;
-    name: string;
-    schemaVersion: number;
-}, now?: Date): TenantEnvelope;

package/dist/tenant/envelope.js

@@ -1,22 +0,0 @@
-import { TenantEnvelopeSchema, } from "@nylorun/core/contracts";
-import { quarantine } from "./quarantine.js";
-export function parseEnvelope(raw, expectedId) {
-    const parsed = TenantEnvelopeSchema.safeParse(raw);
-    if (!parsed.success) {
-        throw quarantine("envelope-invalid", "the Tenant envelope is missing or invalid", expectedId ? { tenantId: expectedId } : {});
-    }
-    if (expectedId !== undefined && parsed.data.id !== expectedId) {
-        throw quarantine("envelope-invalid", `the Tenant envelope id ${parsed.data.id} does not match ${expectedId}`, { tenantId: expectedId });
-    }
-    return parsed.data;
-}
-export function envelopeNow(input, now = new Date()) {
-    const iso = now.toISOString();
-    return {
-        id: input.id,
-        name: input.name,
-        createdAt: iso,
-        updatedAt: iso,
-        schemaVersion: input.schemaVersion,
-    };
-}

package/dist/tenant/quarantine-error.d.ts

@@ -1,6 +0,0 @@
-import type { Quarantine } from "./types.js";
-/** Typed quarantine raised while opening a Tenant Runtime (A7). */
-export declare class QuarantineError extends Error {
-    readonly quarantine: Quarantine;
-    constructor(code: Quarantine["code"], message: string, repair?: string);
-}

package/dist/tenant/quarantine-error.js

@@ -1,9 +0,0 @@
-/** Typed quarantine raised while opening a Tenant Runtime (A7). */
-export class QuarantineError extends Error {
-    quarantine;
-    constructor(code, message, repair = "nylo tenant status") {
-        super(message);
-        this.name = "QuarantineError";
-        this.quarantine = { code, message, repair };
-    }
-}

package/dist/tenant/quarantine.d.ts

@@ -1,27 +0,0 @@
-import type { Quarantine } from "./types.js";
-/** Typed quarantine failure thrown by stores and migration. */
-export declare class QuarantineError extends Error implements Quarantine {
-    readonly code: Quarantine["code"];
-    readonly repair: string;
-    constructor(fields: Quarantine);
-    toQuarantine(): Quarantine;
-}
-export declare function isQuarantineError(error: unknown): error is QuarantineError;
-export declare function asQuarantine(error: unknown): Quarantine | undefined;
-/** CLI-facing repair strings for every quarantine code (B9). */
-export declare function repairFor(code: Quarantine["code"], detail?: {
-    tenantId?: string;
-}): string;
-export declare function quarantine(code: Quarantine["code"], message: string, detail?: {
-    tenantId?: string;
-}): QuarantineError;
-/** Conflict when create bootstrap material does not match an existing Tenant (HTTP 409). */
-export declare class TenantConflictError extends Error {
-    readonly statusCode: 409;
-    constructor(message?: string);
-}
-/** Delete refused because the Tenant still has live work (HTTP 409). */
-export declare class TenantBusyError extends Error {
-    readonly statusCode: 409;
-    constructor(message?: string);
-}

package/dist/tenant/quarantine.js

@@ -1,72 +0,0 @@
-/** Typed quarantine failure thrown by stores and migration. */
-export class QuarantineError extends Error {
-    code;
-    repair;
-    constructor(fields) {
-        super(fields.message);
-        this.name = "QuarantineError";
-        this.code = fields.code;
-        this.repair = fields.repair;
-    }
-    toQuarantine() {
-        return { code: this.code, message: this.message, repair: this.repair };
-    }
-}
-export function isQuarantineError(error) {
-    return error instanceof QuarantineError;
-}
-export function asQuarantine(error) {
-    if (isQuarantineError(error))
-        return error.toQuarantine();
-    if (error &&
-        typeof error === "object" &&
-        "code" in error &&
-        "message" in error &&
-        "repair" in error) {
-        return error;
-    }
-    return undefined;
-}
-/** CLI-facing repair strings for every quarantine code (B9). */
-export function repairFor(code, detail = {}) {
-    const id = detail.tenantId ? ` ${detail.tenantId}` : "";
-    switch (code) {
-        case "kek-missing":
-            return `nylo tenant status${id} — restore vault-kek for this Tenant (ciphertext cannot be opened without it)`;
-        case "corrupt":
-            return `nylo tenant status${id} — restore the Tenant from backup`;
-        case "schema-too-new":
-            return `nylo tenant status${id} — the Tenant was migrated by a newer Runtime; run that version or newer`;
-        case "migration-failed":
-            return `nylo tenant status${id} — inspect the Runtime log for the failed migration, fix it, then restart the Runtime`;
-        case "envelope-invalid":
-            return `nylo tenant status${id} — the Tenant envelope is missing or invalid; restore the Tenant from backup`;
-        case "open-timeout":
-            return `nylo tenant status${id} — open timed out; inspect the Runtime log and Postgres, then retry`;
-        case "open-failed":
-            return `nylo tenant status${id} — inspect Tenant logs and repair before the Host retries open`;
-    }
-}
-export function quarantine(code, message, detail = {}) {
-    return new QuarantineError({
-        code,
-        message,
-        repair: repairFor(code, detail),
-    });
-}
-/** Conflict when create bootstrap material does not match an existing Tenant (HTTP 409). */
-export class TenantConflictError extends Error {
-    statusCode = 409;
-    constructor(message = "Tenant already exists with different bootstrap material") {
-        super(message);
-        this.name = "TenantConflictError";
-    }
-}
-/** Delete refused because the Tenant still has live work (HTTP 409). */
-export class TenantBusyError extends Error {
-    statusCode = 409;
-    constructor(message = "Tenant has live work; pass activeWork=drain|cancel or retry later") {
-        super(message);
-        this.name = "TenantBusyError";
-    }
-}

package/dist/tenant/store-memory.d.ts

@@ -1,16 +0,0 @@
-import type { SessionStore } from "../store/types.js";
-import { type Logger, type OpenTenantRuntime, type TenantConfig, type TenantStore } from "./types.js";
-export interface MemoryTenantStoreOptions {
-    /** When set, each Tenant's directory under this Host root lives as long as the Tenant. */
-    hostRoot?: string;
-    openRuntime: OpenTenantRuntime;
-    configFor: (tenantId: string) => TenantConfig;
-    logger?: Logger;
-}
-export type MemoryTenantStore = TenantStore & {
-    /** Test helper: current Tenant ids. */
-    ids(): string[];
-    /** Test helper: a Session Store on a Tenant's data, as another process would open it. */
-    sessionStore(id: string): SessionStore;
-};
-export declare function createMemoryTenantStore(options: MemoryTenantStoreOptions): MemoryTenantStore;

package/dist/tenant/store-memory.js

@@ -1,111 +0,0 @@
-/**
- * An in-memory Tenant store for tests: each Tenant is a `MemoryStoreData` (its Session
- * Store's data) and an envelope. It behaves like the Postgres store (`store-pg.ts`): the
- * Tenant directory under the Host root, when one is given, is created with the Tenant and
- * removed with it, and `open` hands the Tenant Runtime a fresh Session Store on the Tenant's
- * data. Not a supported profile.
- */
-import { mkdirSync, rmSync } from "node:fs";
-import { isTenantId } from "@nylorun/core/compatibility";
-import { MEMORY_SCHEMA_VERSION, MemorySessionStore, MemoryStoreData, } from "../store/memory.js";
-import { quarantine } from "./quarantine.js";
-import { parseEnvelope } from "./envelope.js";
-import { tenantPaths } from "./paths.js";
-import { bootstrapPrincipal, bootstrapPrincipalMatches } from "./principals.js";
-import { TenantNotFoundError, } from "./types.js";
-export function createMemoryTenantStore(options) {
-    const records = new Map();
-    function sessionStore(id, data) {
-        return new MemorySessionStore({
-            tenantId: id,
-            onError: (error) => options.logger?.error("post-commit step failed", {
-                message: error instanceof Error ? error.message : String(error),
-            }),
-        }, data);
-    }
-    function makeDirectory(id) {
-        if (!options.hostRoot)
-            return;
-        const p = tenantPaths(options.hostRoot, id);
-        mkdirSync(p.root, { recursive: true, mode: 0o700 });
-        for (const dir of [p.home, p.tmp, p.sandboxes, p.pluginData, p.logs])
-            mkdirSync(dir, { recursive: true });
-    }
-    function removeDirectory(id) {
-        if (options.hostRoot)
-            rmSync(tenantPaths(options.hostRoot, id).root, {
-                recursive: true,
-                force: true,
-            });
-    }
-    async function withStore(id, data, fn) {
-        const store = sessionStore(id, data);
-        try {
-            return await fn(store);
-        }
-        finally {
-            await store.close();
-        }
-    }
-    return {
-        ids() {
-            return [...records.keys()];
-        },
-        sessionStore(id) {
-            const record = records.get(id);
-            if (!record)
-                throw new TenantNotFoundError(id);
-            return sessionStore(id, record.data);
-        },
-        async enumerate() {
-            return [...records.keys()].filter(isTenantId).sort();
-        },
-        async readEnvelope(id) {
-            const record = records.get(id);
-            if (!record)
-                throw new TenantNotFoundError(id);
-            return parseEnvelope(record.envelope, id);
-        },
-        async create(envelope, bootstrap) {
-            const parsed = parseEnvelope({ ...envelope, schemaVersion: MEMORY_SCHEMA_VERSION }, envelope.id);
-            if (records.has(parsed.id))
-                return "exists";
-            makeDirectory(parsed.id);
-            const data = new MemoryStoreData();
-            await withStore(parsed.id, data, (store) => store.tx((t) => bootstrapPrincipal(t, bootstrap)));
-            records.set(parsed.id, { envelope: parsed, data });
-            return "created";
-        },
-        async bootstrapMatches(id, bootstrap) {
-            const record = records.get(id);
-            if (!record)
-                return false;
-            return withStore(id, record.data, (store) => store.tx((t) => bootstrapPrincipalMatches(t, bootstrap)));
-        },
-        async open(id) {
-            const record = records.get(id);
-            if (!record)
-                throw new TenantNotFoundError(id);
-            if (record.envelope.schemaVersion > MEMORY_SCHEMA_VERSION)
-                throw quarantine("schema-too-new", `Tenant schema version ${record.envelope.schemaVersion} is newer than this Runtime's ${MEMORY_SCHEMA_VERSION}`, { tenantId: id });
-            makeDirectory(id);
-            const store = sessionStore(id, record.data);
-            try {
-                return await options.openRuntime({ ...options.configFor(id), tenantId: id }, { store, envelope: record.envelope });
-            }
-            catch (error) {
-                await store.close().catch(() => undefined);
-                throw error;
-            }
-        },
-        async trash(id) {
-            records.delete(id);
-            removeDirectory(id);
-        },
-        async removePartial(id) {
-            if (records.has(id))
-                return;
-            removeDirectory(id);
-        },
-    };
-}