ts-workflow-engine-lite 2.1.0

package/dist/src/storage/ArchiveManager.js

@@ -0,0 +1,140 @@
+import * as fs from "fs";
+import * as path from "path";
+import { onHook } from "../event/HookManager.js";
+import { parseEnvInt } from "../utils/env.js";
+import { errorStack, Logger } from "../utils/Logger.js";
+export class ArchiveManager {
+    archiveDir;
+    storage;
+    lastEnsuredDate = null;
+    tempCounter = 0;
+    unsubscribe = [];
+    cleanupTimer;
+    retentionDays;
+    cleanupIntervalMs;
+    constructor(storage, archiveDir, options = {}) {
+        this.storage = storage;
+        this.archiveDir =
+            archiveDir ||
+                process.env.ARCHIVE_DIR ||
+                path.join(process.cwd(), "archive");
+        this.retentionDays =
+            options.retentionDays ??
+                parseEnvInt(process.env.ARCHIVE_RETENTION_DAYS, 90, { min: 0 });
+        this.cleanupIntervalMs =
+            options.cleanupIntervalMs ??
+                parseEnvInt(process.env.ARCHIVE_CLEANUP_INTERVAL_MS, 21_600_000, {
+                    min: 1000,
+                });
+    }
+    initialize() {
+        if (this.unsubscribe.length > 0)
+            return;
+        if (!fs.existsSync(this.archiveDir)) {
+            fs.mkdirSync(this.archiveDir, { recursive: true });
+        }
+        Logger.info("system", "ArchiveManager", `Initializing archiver... Data goes to ${this.archiveDir}`);
+        const handler = this.handleTerminalState.bind(this);
+        this.unsubscribe = [
+            onHook("workflow.completed", handler),
+            onHook("workflow.failed", handler),
+            onHook("workflow.cancelled", handler),
+        ];
+        void this.cleanupExpiredArchives();
+        this.cleanupTimer = setInterval(() => void this.cleanupExpiredArchives(), this.cleanupIntervalMs);
+    }
+    destroy() {
+        this.unsubscribe.forEach((unsubscribe) => unsubscribe());
+        this.unsubscribe = [];
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+    }
+    async handleTerminalState(payload) {
+        const instanceId = payload.instanceId;
+        if (!instanceId)
+            return;
+        try {
+            let instanceData = payload.data || {};
+            if (this.storage) {
+                const fullInstance = await this.storage.loadInstance(instanceId);
+                if (fullInstance) {
+                    instanceData = fullInstance;
+                }
+            }
+            const dateStr = new Date().toISOString().split("T")[0];
+            const dailyDir = await this.ensureDailyDir(dateStr);
+            const filePath = path.join(dailyDir, `${instanceId}.json`);
+            const archiveContent = {
+                _archivedAt: new Date().toISOString(),
+                _terminalEvent: payload.event,
+                ...instanceData,
+            };
+            await this.writeAtomic(filePath, archiveContent);
+            Logger.debug("system", "ArchiveManager", `Successfully archived instance ${instanceId} to ${filePath}`);
+            if (this.storage) {
+                try {
+                    await this.storage.deleteInstance(instanceId);
+                }
+                catch (deleteError) {
+                    Logger.warn("system", "ArchiveManager", `Archived instance ${instanceId} but failed to evict from hot storage: ${errorStack(deleteError) ?? String(deleteError)}`);
+                }
+            }
+        }
+        catch (error) {
+            Logger.error("system", "ArchiveManager", `Failed to archive instance ${instanceId}`, errorStack(error));
+        }
+    }
+    async cleanupExpiredArchives(now = Date.now()) {
+        if (!Number.isFinite(this.retentionDays) || this.retentionDays <= 0) {
+            return 0;
+        }
+        const threshold = now - this.retentionDays * 24 * 60 * 60 * 1000;
+        let deleted = 0;
+        let entries = [];
+        try {
+            entries = await fs.promises.readdir(this.archiveDir, {
+                withFileTypes: true,
+            });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return 0;
+            throw error;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !/^\d{4}-\d{2}-\d{2}$/.test(entry.name)) {
+                continue;
+            }
+            const directoryTime = Date.parse(`${entry.name}T00:00:00.000Z`);
+            if (!Number.isFinite(directoryTime) || directoryTime >= threshold) {
+                continue;
+            }
+            await fs.promises.rm(path.join(this.archiveDir, entry.name), {
+                recursive: true,
+                force: true,
+            });
+            deleted++;
+        }
+        if (deleted > 0) {
+            Logger.info("system", "ArchiveManager", `Removed ${deleted} expired archive directories`);
+        }
+        return deleted;
+    }
+    async ensureDailyDir(dateStr) {
+        const dailyDir = path.join(this.archiveDir, dateStr);
+        if (this.lastEnsuredDate === dateStr) {
+            return dailyDir;
+        }
+        await fs.promises.mkdir(dailyDir, { recursive: true });
+        this.lastEnsuredDate = dateStr;
+        return dailyDir;
+    }
+    async writeAtomic(filePath, value) {
+        const tempPath = `${filePath}.${process.pid}.${Date.now()}.${this.tempCounter++}.tmp`;
+        await fs.promises.writeFile(tempPath, JSON.stringify(value), "utf8");
+        await fs.promises.rename(tempPath, filePath);
+    }
+}
+//# sourceMappingURL=ArchiveManager.js.map

package/dist/src/storage/ArchiveManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArchiveManager.js","sourceRoot":"","sources":["../../../src/storage/ArchiveManager.ts"],"names":[],"mappings":"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"}

package/dist/src/storage/LocalFileStorage.d.ts

@@ -0,0 +1,64 @@
+import type { WorkflowInstance } from "../model/Instance.js";
+import type { WorkflowDefinition } from "../model/Workflow.js";
+import { MemoryStorage } from "./MemoryStorage.js";
+import type { EventRecord, EventWaitingState, HeartbeatState, InstanceMetrics, NodeMetrics, StoredWorkflow, StoredWorkflowVersion } from "./StorageProvider.js";
+export interface LocalFileStorageOptions {
+    directory: string;
+    fsyncOnWrite?: boolean;
+}
+export declare class LocalFileStorage extends MemoryStorage {
+    readonly directory: string;
+    private readonly directories;
+    private readonly fsyncOnWrite;
+    private readonly directoryFsyncQueues;
+    private writeQueues;
+    private persistenceGenerations;
+    private deadLetterEntries;
+    private webhookEntries;
+    private webhookDeliveryEntries;
+    private connected;
+    constructor(options: LocalFileStorageOptions | string);
+    connect(): Promise<void>;
+    saveInstance(instance: WorkflowInstance): Promise<void>;
+    casUpdateInstance(instance: WorkflowInstance): Promise<boolean>;
+    deleteInstance(instanceId: string): Promise<void>;
+    saveWorkflow(workflow: WorkflowDefinition): Promise<void>;
+    deleteWorkflow(workflowId: string): Promise<void>;
+    saveEventWaitingState(state: EventWaitingState): Promise<void>;
+    deleteEventWaitingState(instanceId: string, nodeId: string): Promise<void>;
+    saveWorkflowWithMetadata(workflow: StoredWorkflow): Promise<void>;
+    saveWorkflowVersion(version: StoredWorkflowVersion): Promise<void>;
+    saveInstanceMetrics(metrics: InstanceMetrics): Promise<void>;
+    updateNodeMetrics(instanceId: string, nodeId: string, metrics: NodeMetrics): Promise<void>;
+    saveEvent(event: EventRecord): Promise<void>;
+    deleteEvent(eventId: string): Promise<void>;
+    saveHeartbeat(state: HeartbeatState): Promise<void>;
+    deleteHeartbeat(instanceId: string, nodeId: string): Promise<void>;
+    cleanupStaleEvents(retentionDays: number): Promise<number>;
+    cleanupExpiredHeartbeats(): Promise<number>;
+    cleanupStaleInstances(maxAgeMs: number): number;
+    close(): Promise<void>;
+    saveDeadLetterEntry(entry: unknown): Promise<void>;
+    loadAllDeadLetterEntries(): Promise<unknown[]>;
+    deleteDeadLetterEntry(id: string): Promise<void>;
+    saveWebhookEntry(entry: unknown): Promise<void>;
+    loadAllWebhookEntries(): Promise<unknown[]>;
+    deleteWebhookEntry(id: string): Promise<void>;
+    saveWebhookDeliveryEntry(entry: unknown): Promise<void>;
+    loadAllWebhookDeliveryEntries(): Promise<unknown[]>;
+    deleteWebhookDeliveryEntry(id: string): Promise<void>;
+    private removeStaleInstanceFiles;
+    private restoreCollection;
+    private restoreInstance;
+    private restoreEvent;
+    private persist;
+    private persistOrRollback;
+    private fsyncDirectory;
+    private removeFile;
+    private filePath;
+    private safeId;
+    private decodeId;
+    private listFiles;
+    private quarantine;
+    private isJsonSerializable;
+}

package/dist/src/storage/LocalFileStorage.js

@@ -0,0 +1,470 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { mapWithConcurrency } from "../utils/concurrency.js";
+import { Logger } from "../utils/Logger.js";
+import { MemoryStorage } from "./MemoryStorage.js";
+export class LocalFileStorage extends MemoryStorage {
+    directory;
+    directories;
+    fsyncOnWrite;
+    directoryFsyncQueues = new Map();
+    writeQueues = new Map();
+    persistenceGenerations = new Map();
+    deadLetterEntries = new Map();
+    webhookEntries = new Map();
+    webhookDeliveryEntries = new Map();
+    connected = false;
+    constructor(options) {
+        super();
+        this.directory = typeof options === "string" ? options : options.directory;
+        this.fsyncOnWrite =
+            typeof options === "string" ? false : (options.fsyncOnWrite ?? false);
+        this.directories = {
+            instances: path.join(this.directory, "instances"),
+            workflows: path.join(this.directory, "workflows"),
+            "workflow-metadata": path.join(this.directory, "workflow-metadata"),
+            "workflow-versions": path.join(this.directory, "workflow-versions"),
+            waiting: path.join(this.directory, "waiting"),
+            metrics: path.join(this.directory, "metrics"),
+            events: path.join(this.directory, "events"),
+            heartbeats: path.join(this.directory, "heartbeats"),
+            dlq: path.join(this.directory, "dlq"),
+            webhooks: path.join(this.directory, "webhooks"),
+            "webhook-deliveries": path.join(this.directory, "webhook-deliveries"),
+        };
+    }
+    async connect() {
+        for (const directory of Object.values(this.directories)) {
+            await fs.promises.mkdir(directory, { recursive: true });
+            await fs.promises.mkdir(path.join(directory, "corrupt"), {
+                recursive: true,
+            });
+        }
+        await super.connect();
+        await this.restoreCollection("instances", async (id, value) => super.saveInstance(this.restoreInstance(value, id)));
+        await this.restoreCollection("workflows", async (_id, value) => super.saveWorkflow(value));
+        await this.restoreCollection("workflow-metadata", async (_id, value) => super.saveWorkflowWithMetadata(value));
+        await this.restoreCollection("workflow-versions", async (_id, value) => super.saveWorkflowVersion(value));
+        await this.restoreCollection("waiting", async (_id, value) => super.saveEventWaitingState(value));
+        await this.restoreCollection("metrics", async (_id, value) => super.saveInstanceMetrics(value));
+        await this.restoreCollection("events", async (_id, value) => super.saveEvent(this.restoreEvent(value)));
+        await this.restoreCollection("heartbeats", async (_id, value) => super.saveHeartbeat(value));
+        await this.restoreCollection("dlq", async (id, value) => {
+            this.deadLetterEntries.set(id, value);
+        });
+        await this.restoreCollection("webhooks", async (id, value) => {
+            this.webhookEntries.set(id, value);
+        });
+        await this.restoreCollection("webhook-deliveries", async (id, value) => {
+            this.webhookDeliveryEntries.set(id, value);
+        });
+        this.connected = true;
+        Logger.info("system", "storage", `Local file storage restored from ${this.directory}`);
+    }
+    async saveInstance(instance) {
+        const previous = await super.loadInstance(instance.instanceId);
+        await super.saveInstance(instance);
+        await this.persistOrRollback("instances", instance.instanceId, await super.loadInstance(instance.instanceId), async () => {
+            if (previous)
+                await super.saveInstance(previous);
+            else
+                await super.deleteInstance(instance.instanceId);
+        });
+    }
+    async casUpdateInstance(instance) {
+        const previous = await super.loadInstance(instance.instanceId);
+        const updated = await super.casUpdateInstance(instance);
+        if (updated) {
+            await this.persistOrRollback("instances", instance.instanceId, await super.loadInstance(instance.instanceId), async () => {
+                if (previous)
+                    await super.saveInstance(previous);
+            });
+        }
+        return updated;
+    }
+    async deleteInstance(instanceId) {
+        await super.deleteInstance(instanceId);
+        await this.removeFile("instances", instanceId);
+    }
+    async saveWorkflow(workflow) {
+        const previous = await super.loadWorkflow(workflow.id);
+        await super.saveWorkflow(workflow);
+        if (this.isJsonSerializable(workflow)) {
+            await this.persistOrRollback("workflows", workflow.id, workflow, async () => {
+                if (previous)
+                    await super.saveWorkflow(previous);
+                else
+                    await super.deleteWorkflow(workflow.id);
+            });
+        }
+        else {
+            Logger.warn("system", "storage", `Workflow ${workflow.id} contains functions and was not persisted to disk`);
+        }
+    }
+    async deleteWorkflow(workflowId) {
+        await super.deleteWorkflow(workflowId);
+        await this.removeFile("workflows", workflowId);
+        await this.removeFile("workflow-metadata", workflowId);
+        const versions = await this.listFiles("workflow-versions");
+        await Promise.all(versions
+            .filter((id) => id.startsWith(`${workflowId}__`))
+            .map((id) => this.removeFile("workflow-versions", id)));
+    }
+    async saveEventWaitingState(state) {
+        const previous = await super.loadEventWaitingState(state.instanceId, state.nodeId);
+        await super.saveEventWaitingState(state);
+        await this.persistOrRollback("waiting", `${state.instanceId}__${state.nodeId}`, state, async () => {
+            if (previous)
+                await super.saveEventWaitingState(previous);
+            else
+                await super.deleteEventWaitingState(state.instanceId, state.nodeId);
+        });
+    }
+    async deleteEventWaitingState(instanceId, nodeId) {
+        await super.deleteEventWaitingState(instanceId, nodeId);
+        await this.removeFile("waiting", `${instanceId}__${nodeId}`);
+    }
+    async saveWorkflowWithMetadata(workflow) {
+        const previous = await super.loadWorkflowWithMetadata(workflow.id);
+        await super.saveWorkflowWithMetadata(workflow);
+        if (this.isJsonSerializable(workflow.definition)) {
+            await this.persistOrRollback("workflow-metadata", workflow.id, workflow, async () => {
+                if (previous)
+                    await super.saveWorkflowWithMetadata(previous);
+            });
+        }
+    }
+    async saveWorkflowVersion(version) {
+        const previous = await super.loadWorkflowVersion(version.id, version.version);
+        await super.saveWorkflowVersion(version);
+        if (this.isJsonSerializable(version.definition)) {
+            await this.persistOrRollback("workflow-versions", `${version.id}__${version.version}`, version, async () => {
+                if (previous)
+                    await super.saveWorkflowVersion(previous);
+            });
+        }
+    }
+    async saveInstanceMetrics(metrics) {
+        const previous = await super.loadInstanceMetrics(metrics.instanceId);
+        await super.saveInstanceMetrics(metrics);
+        await this.persistOrRollback("metrics", metrics.instanceId, await super.loadInstanceMetrics(metrics.instanceId), async () => {
+            if (previous)
+                await super.saveInstanceMetrics(previous);
+        });
+    }
+    async updateNodeMetrics(instanceId, nodeId, metrics) {
+        const previous = await super.loadInstanceMetrics(instanceId);
+        await super.updateNodeMetrics(instanceId, nodeId, metrics);
+        await this.persistOrRollback("metrics", instanceId, await super.loadInstanceMetrics(instanceId), async () => {
+            if (previous)
+                await super.saveInstanceMetrics(previous);
+        });
+    }
+    async saveEvent(event) {
+        const previous = await super.loadEvent(event.id);
+        await super.saveEvent(event);
+        await this.persistOrRollback("events", event.id, await super.loadEvent(event.id), async () => {
+            if (previous)
+                await super.saveEvent(previous);
+            else
+                await super.deleteEvent(event.id);
+        });
+    }
+    async deleteEvent(eventId) {
+        await super.deleteEvent(eventId);
+        await this.removeFile("events", eventId);
+    }
+    async saveHeartbeat(state) {
+        const previous = (await super.loadAllHeartbeats()).find((hb) => hb.heartbeatKey === state.heartbeatKey);
+        await super.saveHeartbeat(state);
+        await this.persistOrRollback("heartbeats", state.heartbeatKey, state, async () => {
+            if (previous)
+                await super.saveHeartbeat(previous);
+            else
+                await super.deleteHeartbeat(state.instanceId, state.nodeId);
+        });
+    }
+    async deleteHeartbeat(instanceId, nodeId) {
+        await super.deleteHeartbeat(instanceId, nodeId);
+        await this.removeFile("heartbeats", `${instanceId}:${nodeId}`);
+    }
+    async cleanupStaleEvents(retentionDays) {
+        const deleted = await super.cleanupStaleEvents(retentionDays);
+        const retained = await super.queryEvents({
+            page: 1,
+            pageSize: 100_000_000,
+        });
+        const retainedIds = new Set(retained.events.map((event) => event.id));
+        for (const id of await this.listFiles("events")) {
+            if (!retainedIds.has(id))
+                await this.removeFile("events", id);
+        }
+        return deleted;
+    }
+    async cleanupExpiredHeartbeats() {
+        const deleted = await super.cleanupExpiredHeartbeats();
+        const retained = new Set((await super.loadAllHeartbeats()).map((heartbeat) => `${heartbeat.instanceId}:${heartbeat.nodeId}`));
+        for (const id of await this.listFiles("heartbeats")) {
+            if (!retained.has(id))
+                await this.removeFile("heartbeats", id);
+        }
+        return deleted;
+    }
+    cleanupStaleInstances(maxAgeMs) {
+        const cleaned = super.cleanupStaleInstances(maxAgeMs);
+        void this.removeStaleInstanceFiles(maxAgeMs);
+        return cleaned;
+    }
+    async close() {
+        await Promise.all(this.writeQueues.values());
+        this.connected = false;
+        await super.close();
+    }
+    async saveDeadLetterEntry(entry) {
+        const id = entry.id;
+        if (!id)
+            throw new Error("Dead-letter entry requires an id");
+        this.deadLetterEntries.set(id, entry);
+        await this.persist("dlq", id, entry);
+    }
+    async loadAllDeadLetterEntries() {
+        return Array.from(this.deadLetterEntries.values());
+    }
+    async deleteDeadLetterEntry(id) {
+        this.deadLetterEntries.delete(id);
+        await this.removeFile("dlq", id);
+    }
+    async saveWebhookEntry(entry) {
+        const id = entry.id;
+        if (!id)
+            throw new Error("Webhook entry requires an id");
+        this.webhookEntries.set(id, entry);
+        await this.persist("webhooks", id, entry);
+    }
+    async loadAllWebhookEntries() {
+        return Array.from(this.webhookEntries.values());
+    }
+    async deleteWebhookEntry(id) {
+        this.webhookEntries.delete(id);
+        await this.removeFile("webhooks", id);
+    }
+    async saveWebhookDeliveryEntry(entry) {
+        const id = entry.id;
+        if (!id)
+            throw new Error("Webhook delivery entry requires an id");
+        this.webhookDeliveryEntries.set(id, entry);
+        await this.persist("webhook-deliveries", id, entry);
+    }
+    async loadAllWebhookDeliveryEntries() {
+        return Array.from(this.webhookDeliveryEntries.values());
+    }
+    async deleteWebhookDeliveryEntry(id) {
+        this.webhookDeliveryEntries.delete(id);
+        await this.removeFile("webhook-deliveries", id);
+    }
+    async removeStaleInstanceFiles(maxAgeMs) {
+        const threshold = Date.now() - maxAgeMs;
+        const files = await this.listFiles("instances");
+        for (const id of files) {
+            const instance = await super.loadInstance(id);
+            if (!instance)
+                await this.removeFile("instances", id);
+            else if ((instance.updatedAt?.getTime?.() ?? 0) < threshold &&
+                ["completed", "failed"].includes(instance.status)) {
+                await this.removeFile("instances", id);
+            }
+        }
+    }
+    async restoreCollection(collection, restore) {
+        const ids = await this.listFiles(collection);
+        const results = await mapWithConcurrency(ids, async (id) => {
+            try {
+                const value = JSON.parse(await fs.promises.readFile(this.filePath(collection, id), "utf8"));
+                return { ok: true, id, value };
+            }
+            catch (error) {
+                return { ok: false, id, error };
+            }
+        });
+        for (const result of results) {
+            if (!result.ok) {
+                await this.quarantine(collection, result.id, result.error);
+                continue;
+            }
+            try {
+                await restore(result.id, result.value);
+            }
+            catch (error) {
+                Logger.error("system", "storage", `Failed to restore ${collection} record ${result.id}; leaving the file in place`, error instanceof Error ? error.stack : String(error));
+            }
+        }
+    }
+    restoreInstance(value, id) {
+        const instance = value;
+        return {
+            ...instance,
+            instanceId: instance.instanceId || id,
+            createdAt: new Date(instance.createdAt),
+            updatedAt: new Date(instance.updatedAt),
+            history: (instance.history ?? []).map((entry) => ({
+                ...entry,
+                timestamp: new Date(entry.timestamp),
+            })),
+        };
+    }
+    restoreEvent(event) {
+        return { ...event, timestamp: Number(event.timestamp) };
+    }
+    async persist(collection, id, value) {
+        if (!this.connected)
+            return;
+        if (value === null || value === undefined)
+            return;
+        const key = this.filePath(collection, id);
+        const operation = async () => {
+            const temp = `${key}.${process.pid}.${Date.now()}.tmp`;
+            const contents = JSON.stringify(value);
+            if (!this.fsyncOnWrite) {
+                await fs.promises.writeFile(temp, contents, "utf8");
+            }
+            else {
+                const handle = await fs.promises.open(temp, "w");
+                try {
+                    await handle.writeFile(contents, "utf8");
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            await fs.promises.rename(temp, key);
+            if (this.fsyncOnWrite) {
+                await this.fsyncDirectory(path.dirname(key));
+            }
+        };
+        const previous = this.writeQueues.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        this.writeQueues.set(key, current);
+        try {
+            await current;
+        }
+        finally {
+            if (this.writeQueues.get(key) === current) {
+                this.writeQueues.delete(key);
+            }
+        }
+    }
+    async persistOrRollback(collection, id, value, rollback) {
+        const key = this.filePath(collection, id);
+        const generation = (this.persistenceGenerations.get(key) ?? 0) + 1;
+        this.persistenceGenerations.set(key, generation);
+        try {
+            await this.persist(collection, id, value);
+        }
+        catch (error) {
+            if (this.persistenceGenerations.get(key) === generation) {
+                await rollback();
+            }
+            Logger.error("system", "storage", `Failed to persist ${collection}/${id} to disk${this.persistenceGenerations.get(key) === generation ? "; rolled back in-memory state" : "; a newer mutation remains in memory"}`, error instanceof Error ? error.stack : String(error));
+            throw error;
+        }
+    }
+    async fsyncDirectory(directory) {
+        const pending = this.directoryFsyncQueues.get(directory);
+        if (pending) {
+            await pending;
+            return;
+        }
+        const operation = (async () => {
+            const handle = await fs.promises.open(directory, "r");
+            try {
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        })();
+        this.directoryFsyncQueues.set(directory, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.directoryFsyncQueues.get(directory) === operation) {
+                this.directoryFsyncQueues.delete(directory);
+            }
+        }
+    }
+    async removeFile(collection, id) {
+        const key = this.filePath(collection, id);
+        try {
+            await fs.promises.unlink(key);
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT")
+                throw error;
+        }
+    }
+    filePath(collection, id) {
+        return path.join(this.directories[collection], `${this.safeId(id)}.json`);
+    }
+    safeId(id) {
+        return encodeURIComponent(id);
+    }
+    decodeId(name) {
+        try {
+            return decodeURIComponent(name);
+        }
+        catch {
+            return null;
+        }
+    }
+    async listFiles(collection) {
+        const entries = await fs.promises.readdir(this.directories[collection], {
+            withFileTypes: true,
+        });
+        const ids = [];
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".json"))
+                continue;
+            const id = this.decodeId(entry.name.slice(0, -5));
+            if (id === null) {
+                Logger.warn("system", "storage", `Skipping ${collection} file with an undecodable name`, { fileName: entry.name });
+                continue;
+            }
+            ids.push(id);
+        }
+        return ids;
+    }
+    async quarantine(collection, id, error) {
+        const source = this.filePath(collection, id);
+        const target = path.join(this.directories[collection], "corrupt", `${this.safeId(id)}-${Date.now()}.json`);
+        try {
+            await fs.promises.rename(source, target);
+        }
+        catch {
+        }
+        Logger.error("system", "storage", `Quarantined corrupt ${collection} record ${id}`, error instanceof Error ? error.stack : String(error));
+    }
+    isJsonSerializable(value) {
+        const seen = new WeakSet();
+        const inspect = (current) => {
+            if (typeof current === "function" || typeof current === "symbol") {
+                return false;
+            }
+            if (current === null || typeof current !== "object") {
+                return true;
+            }
+            if (seen.has(current))
+                return false;
+            seen.add(current);
+            return Object.values(current).every(inspect);
+        };
+        try {
+            return inspect(value) && JSON.stringify(value) !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=LocalFileStorage.js.map