@x12i/static-memorix 2.0.0

package/dist/routes/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyRequest } from "fastify";
+import type { ExplorerQueryParams } from "../types.js";
+export declare function qp(request: FastifyRequest): ExplorerQueryParams;
+export declare function str(v: unknown, fallback?: string): string;

package/dist/routes/helpers.js

@@ -0,0 +1,29 @@
+export function qp(request) {
+    const q = (request.query || {});
+    return {
+        filter: q.filter,
+        sort: q.sort,
+        searchText: q.searchText,
+        q: q.q,
+        limit: q.limit,
+        offset: q.offset,
+        skip: q.skip,
+        includeTotal: q.includeTotal === "1" || q.includeTotal === "true",
+        include: q.include,
+        mode: q.mode,
+        listId: q.listId,
+        entityName: q.entityName,
+        sourceLens: q.sourceLens,
+        target: q.target,
+        includeExactCounts: q.includeExactCounts === "1" || q.includeExactCounts === "true",
+        includeInventory: q.includeInventory === "1" || q.includeInventory === "true",
+        memoryId: q.memoryId,
+        recordId: q.recordId,
+        entityId: q.entityId,
+        eventId: q.eventId,
+        knowledgeId: q.knowledgeId,
+    };
+}
+export function str(v, fallback = "") {
+    return v === undefined || v === null ? fallback : String(v);
+}

package/dist/routes/index.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export declare function registerRoutes(app: FastifyInstance): Promise<void>;

package/dist/routes/index.js

@@ -0,0 +1,402 @@
+import { store } from "../storage/InMemoryStore.js";
+import { buildMemorixDbString, buildCataloxDbString, buildDataFilePrefix, buildMetadataFilePrefix, metadataWritesEnabled, } from "../config.js";
+import { listObjectTypes } from "../engine/inventory.js";
+import { computeInventory, computeInventorySummary, computeInventoryIssues, computeGraph, } from "../engine/inventory.js";
+import { qp, str } from "./helpers.js";
+import { getSnapshotNormalized, getSnapshotAssociated, getSnapshotAssociatedProperty, getAssociatedProperties, } from "../engine/snapshots.js";
+import { getRecordsCollection, getRecordsFull, getRecordsItem, getRawCollection, getRawItem, getWorkspaceRecords, getRecordContent, } from "../engine/records.js";
+import { listListDescriptors, getListDescriptor, executeListDescriptor, suggestListExtensions, } from "../engine/lists.js";
+import { getMergedNarratives, getRawNarratives, queryNarrativeRecords, } from "../engine/narratives.js";
+import { computeRootPropertyCatalog } from "../engine/objectTypes.js";
+import { loadWriteDescriptor, validateInputSchema, executeOperation, } from "../engine/write.js";
+import { planAssociations, applyAssociations, verifyAssociations, } from "../engine/associations.js";
+import { MOCKS_DIR } from "../config.js";
+import fs from "node:fs";
+import path from "node:path";
+export async function registerRoutes(app) {
+    // ---------- A. Health & System Diagnostics ----------
+    app.get("/health", async () => ({ ok: true }));
+    app.get("/api/explorer/health", async (request) => {
+        const includeInventory = qp(request).includeInventory;
+        const objectTypes = listObjectTypes();
+        const base = {
+            ok: true,
+            mongoUriConfigured: true,
+            discoverySample: objectTypes,
+            memorixDb: buildMemorixDbString(),
+            cataloxDb: buildCataloxDbString(),
+            fileRouting: {
+                entitiesPrefix: buildDataFilePrefix("snapshots"),
+                eventsPrefix: buildDataFilePrefix("events"),
+                memoryPrefix: buildDataFilePrefix("memory"),
+                metadataPrefix: buildMetadataFilePrefix(),
+            },
+        };
+        if (includeInventory) {
+            const rows = computeInventory({ sourceLens: "catalox-first" });
+            const summary = computeInventorySummary(rows, { includeExactCounts: false });
+            return { ...base, inventorySummary: summary };
+        }
+        return base;
+    });
+    // ---------- B. Inventory & Graph Engine ----------
+    app.get("/api/explorer/inventory/collections", async (request) => {
+        const rows = computeInventory(qp(request));
+        return { rows, total: rows.length };
+    });
+    app.get("/api/explorer/inventory/summary", async (request) => {
+        const rows = computeInventory(qp(request));
+        const summary = computeInventorySummary(rows, qp(request));
+        return { summary, rows };
+    });
+    app.get("/api/explorer/inventory/issues", async (request) => {
+        const rows = computeInventory(qp(request));
+        const issues = computeInventoryIssues(rows);
+        return { issues, total: issues.length };
+    });
+    app.get("/api/explorer/inventory/graph", async (request) => {
+        const rows = computeInventory(qp(request));
+        return computeGraph(rows);
+    });
+    // ---------- C. Snapshots & Associated Data Pipeline ----------
+    app.get("/api/explorer/snapshots/:objectType/:recordId", async (request, reply) => {
+        const { objectType, recordId } = request.params;
+        const q = qp(request);
+        const result = getSnapshotNormalized(objectType, recordId, q.include);
+        if (!result)
+            return send404(reply, `Snapshot not found: ${objectType}/${recordId}`);
+        return result;
+    });
+    app.get("/api/explorer/snapshots/:objectType/:recordId/associated", async (request, reply) => {
+        const { objectType, recordId } = request.params;
+        const result = getSnapshotAssociated(objectType, recordId);
+        if (!result)
+            return send404(reply, `Snapshot not found: ${objectType}/${recordId}`);
+        return result;
+    });
+    app.get("/api/explorer/snapshots/:objectType/:recordId/associated/:propertyName", async (request, reply) => {
+        const { objectType, recordId, propertyName } = request.params;
+        const result = getSnapshotAssociatedProperty(objectType, recordId, propertyName);
+        if (result === undefined)
+            return send404(reply, `Associated property not found: ${propertyName}`);
+        return result;
+    });
+    app.get("/api/explorer/snapshots/:objectType/associated-properties", async (request) => {
+        const { objectType } = request.params;
+        return { objectType, properties: getAssociatedProperties(objectType) };
+    });
+    app.post("/api/explorer/associations/plan", async (request) => {
+        const { objectType } = (request.body || {});
+        return { plans: planAssociations(objectType) };
+    });
+    app.post("/api/explorer/associations/apply", async (request) => {
+        const { expectedPlanFingerprint, objectType } = (request.body || {});
+        return { results: applyAssociations(expectedPlanFingerprint, objectType) };
+    });
+    app.post("/api/explorer/associations/verify", async (request) => {
+        const { expectedPlanFingerprint, objectType } = (request.body || {});
+        return { results: verifyAssociations(expectedPlanFingerprint, objectType) };
+    });
+    // ---------- D. Records Engine ----------
+    app.get("/api/explorer/records/collection", async (request) => {
+        const q = qp(request);
+        return await getRecordsCollection(q);
+    });
+    app.get("/api/explorer/records/full", async (request) => {
+        const q = qp(request);
+        const entityName = str(q.entityName);
+        const recordId = str(request.query.recordId);
+        if (!entityName || !recordId)
+            return { error: "entityName and recordId are required" };
+        return getRecordsFull(entityName, recordId);
+    });
+    app.get("/api/explorer/records/item", async (request, reply) => {
+        const q = qp(request);
+        const entityName = str(q.entityName);
+        const recordId = str(request.query.recordId);
+        const itemDescriptor = request.query.itemDescriptor
+            ? JSON.parse(request.query.itemDescriptor)
+            : undefined;
+        const result = getRecordsItem(entityName, recordId, itemDescriptor);
+        if (!result)
+            return send404(reply, `Item not found: ${entityName}/${recordId}`);
+        return result;
+    });
+    app.get("/api/explorer/records/content", async (request, reply) => {
+        const q = qp(request);
+        const entityName = str(q.entityName) || (q.target === "memory" ? "memory" : "");
+        const contentType = request.query.contentType;
+        const identity = {};
+        if (q.recordId)
+            identity.recordId = q.recordId;
+        if (q.entityId)
+            identity.entityId = q.entityId;
+        if (q.eventId)
+            identity.eventId = q.eventId;
+        if (q.knowledgeId)
+            identity.knowledgeId = q.knowledgeId;
+        if (q.memoryId)
+            identity.memoryId = q.memoryId;
+        if (!contentType || Object.keys(identity).length === 0) {
+            return { ok: false, error: "contentType and at least one identity key required" };
+        }
+        const result = getRecordContent(entityName, contentType, identity);
+        if (!result)
+            return send404(reply, `Content not found: ${entityName}/${contentType}`);
+        return result;
+    });
+    app.get("/api/explorer/records/raw-collection", async (request) => {
+        const { entityName, collectionName } = request.query;
+        const name = collectionName || entityName;
+        return getRawCollection(str(entityName), str(name));
+    });
+    app.get("/api/explorer/records/raw-item", async (request, reply) => {
+        const { collectionName, recordId } = request.query;
+        const result = getRawItem(str(collectionName), str(recordId));
+        if (!result)
+            return send404(reply, `Raw item not found: ${collectionName}/${recordId}`);
+        return result;
+    });
+    app.get("/api/explorer/records/workspace", async (request) => {
+        return await getWorkspaceRecords(qp(request));
+    });
+    // ---------- E. Lists Subsystem ----------
+    app.get("/api/explorer/lists", async (request) => {
+        const { entityName } = request.query;
+        return { lists: listListDescriptors(entityName) };
+    });
+    app.get("/api/explorer/lists/:listId", async (request, reply) => {
+        const { listId } = request.params;
+        const desc = getListDescriptor(listId);
+        if (!desc)
+            return send404(reply, `List descriptor not found: ${listId}`);
+        return desc;
+    });
+    app.get("/api/explorer/lists/:listId/records", async (request, reply) => {
+        const { listId } = request.params;
+        const desc = getListDescriptor(listId);
+        if (!desc)
+            return send404(reply, `List descriptor not found: ${listId}`);
+        const result = await executeListDescriptor(desc, qp(request));
+        return result;
+    });
+    app.get("/api/explorer/lists/:listId/records-ws", async (request, reply) => {
+        const { listId } = request.params;
+        const desc = getListDescriptor(listId);
+        if (!desc)
+            return send404(reply, `List descriptor not found: ${listId}`);
+        const result = await executeListDescriptor(desc, qp(request));
+        return result;
+    });
+    app.get("/api/explorer/lists/suggest", async (request) => {
+        const { entityName } = request.query;
+        return suggestListExtensions(str(entityName));
+    });
+    app.post("/api/explorer/lists", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const body = (request.body || {});
+        const listId = body.listId || body.id;
+        if (!listId)
+            return { error: "listId required" };
+        store.setMeta(`lists/${listId}`, { ...body, listId });
+        return { ok: true, listId };
+    });
+    app.patch("/api/explorer/lists/:listId", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const { listId } = request.params;
+        const existing = getListDescriptor(listId) || {};
+        const updated = { ...existing, ...(request.body || {}), listId };
+        store.setMeta(`lists/${listId}`, updated);
+        return { ok: true, listId, descriptor: updated };
+    });
+    app.put("/api/explorer/lists/:listId/sort", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const { listId } = request.params;
+        const existing = getListDescriptor(listId) || {};
+        const updated = { ...existing, sort: (request.body || {}).sort, listId };
+        store.setMeta(`lists/${listId}`, updated);
+        return { ok: true, listId, descriptor: updated };
+    });
+    app.delete("/api/explorer/lists/:listId", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const { listId } = request.params;
+        store.deleteMeta(`lists/${listId}`);
+        await store.flushAll();
+        return { ok: true, deleted: listId };
+    });
+    // ---------- F. Narratives Engine ----------
+    app.get("/api/explorer/narratives", async () => {
+        return { narratives: getMergedNarratives() };
+    });
+    app.get("/api/explorer/narratives/:entity", async (request) => {
+        const { entity } = request.params;
+        return { entity, narratives: getMergedNarratives(entity) };
+    });
+    app.get("/api/explorer/narratives/:entity/raw", async (request) => {
+        const { entity } = request.params;
+        return { entity, raw: getRawNarratives(entity) };
+    });
+    app.get("/api/explorer/narratives/:entity/:key", async (request, reply) => {
+        const { entity, key } = request.params;
+        const merged = getMergedNarratives(entity);
+        const found = merged.find((n) => n.key === key);
+        if (!found)
+            return send404(reply, `Narrative not found: ${entity}/${key}`);
+        return found;
+    });
+    app.get("/api/explorer/narratives/:entity/:key/records", async (request) => {
+        const { entity, key } = request.params;
+        return { entity, key, records: queryNarrativeRecords(entity, key) };
+    });
+    app.post("/api/explorer/narratives", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const { entity, key, ...rest } = (request.body || {});
+        if (!entity || !key)
+            return { error: "entity and key required" };
+        const authored = getRawNarratives(entity);
+        authored[key] = { key, ...rest };
+        store.setMeta(`narratives/${entity}`, authored);
+        return { ok: true, entity, key };
+    });
+    app.patch("/api/explorer/narratives/:entity/:key", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const { entity, key } = request.params;
+        const authored = getRawNarratives(entity);
+        authored[key] = { ...authored[key], ...(request.body || {}), key };
+        store.setMeta(`narratives/${entity}`, authored);
+        return { ok: true, entity, key, descriptor: authored[key] };
+    });
+    app.delete("/api/explorer/narratives/:entity/:key", async (request) => {
+        if (!metadataWritesEnabled()) {
+            return { ok: false, error: "Metadata writes are disabled" };
+        }
+        const { entity, key } = request.params;
+        const authored = getRawNarratives(entity);
+        delete authored[key];
+        store.setMeta(`narratives/${entity}`, authored);
+        return { ok: true, entity, key };
+    });
+    // ---------- G. Object Types & Root Property Catalog ----------
+    app.get("/api/explorer/object-types", async () => {
+        return { objectTypes: listObjectTypes().map((name) => store.getMeta(`object-types/${name}`)) };
+    });
+    app.get("/api/explorer/object-types/:name/root-property-catalog", async (request) => {
+        const { name } = request.params;
+        const meta = store.getMeta(`object-types/${name}`);
+        return {
+            objectType: name,
+            rootPropertyCatalog: meta?.rootPropertyCatalog || [],
+        };
+    });
+    app.post("/api/explorer/object-types/:name/root-property-catalog/compute", async (request) => {
+        const { name } = request.params;
+        const entries = computeRootPropertyCatalog(name);
+        return { objectType: name, computed: true, rootPropertyCatalog: entries };
+    });
+    // ---------- H. Record Write Engine ----------
+    app.post("/api/explorer/records/write", async (request, reply) => {
+        const { writeDescriptorId, operation = "add", input, records, dryRun = false, validateOnly = false, } = (request.body || {});
+        if (!writeDescriptorId)
+            return reply.code(400).send({ error: "writeDescriptorId required", ok: false });
+        if (!["add", "upsert", "patch", "replace", "delete"].includes(operation)) {
+            return reply.code(400).send({ ok: false, error: `Unsupported operation: ${operation}` });
+        }
+        const writeSpec = loadWriteDescriptor(writeDescriptorId);
+        const targetCollection = writeSpec.targetCollection;
+        if (!targetCollection)
+            return reply.code(400).send({ error: "writeDescriptor missing targetCollection", ok: false });
+        const data = input ?? records;
+        if (data === undefined || data === null) {
+            return reply.code(400).send({ ok: false, error: "input or records required" });
+        }
+        const validation = validateInputSchema(writeSpec, data, operation);
+        if (!validation.ok) {
+            return reply.code(400).send({ ok: false, validated: false, errors: validation.errors });
+        }
+        if (validateOnly)
+            return { ok: true, validated: true };
+        const results = executeOperation({
+            target: targetCollection,
+            op: operation,
+            data,
+            persist: !dryRun,
+        });
+        if (!dryRun) {
+            await store.flushAll();
+        }
+        return { ok: true, count: results.length, operation, dryRun, results };
+    });
+    app.delete("/api/explorer/records/item", async (request, reply) => {
+        const { entityName, recordId, writeDescriptorId } = (request.query || {});
+        if (!entityName || !recordId || !writeDescriptorId) {
+            return reply.code(400).send({
+                ok: false,
+                error: "entityName, recordId, and writeDescriptorId query params are required",
+            });
+        }
+        const writeSpec = loadWriteDescriptor(writeDescriptorId);
+        const expectedTarget = `${entityName}/snapshots`;
+        if (writeSpec.targetCollection !== expectedTarget) {
+            return reply.code(400).send({
+                ok: false,
+                error: `Write descriptor targets ${writeSpec.targetCollection}, not ${expectedTarget}`,
+            });
+        }
+        const validation = validateInputSchema(writeSpec, { recordId }, "delete");
+        if (!validation.ok) {
+            return reply.code(400).send({ ok: false, validated: false, errors: validation.errors });
+        }
+        const removed = executeOperation({
+            target: writeSpec.targetCollection,
+            op: "delete",
+            data: { recordId },
+        });
+        await store.flushAll();
+        return { ok: true, count: removed.length, removed };
+    });
+    app.get("/api/explorer/object-types/:name", async (request, reply) => {
+        const { name } = request.params;
+        const meta = store.getMeta(`object-types/${name}`);
+        if (!meta)
+            return send404(reply, `Object type not found: ${name}`);
+        return meta;
+    });
+    // ---------- I. Agents Engine ----------
+    app.get("/api/explorer/agents", async () => {
+        const agents = store.getMeta("agents");
+        return agents || { agents: [] };
+    });
+    // ---- Authix / M2M Auth Shim ----
+    app.post("/api/explorer/auth/token", async () => ({
+        access_token: "mock-m2m-token",
+        token_type: "Bearer",
+        expires_in: 3600,
+    }));
+    // ---- Demo UI ----
+    // The demo app served at /demo uses the Explorer API exclusively for its
+    // CRUD (records/collection, records/write, DELETE records/item). No separate
+    // /api/state flow is needed.
+    app.get("/demo", async (_request, reply) => {
+        const demoPath = path.join(MOCKS_DIR, "demo.html");
+        if (!fs.existsSync(demoPath)) {
+            return reply.code(404).send({ ok: false, error: "demo.html not found" });
+        }
+        const html = fs.readFileSync(demoPath, "utf8");
+        return reply.type("text/html").send(html);
+    });
+}
+function send404(reply, message) {
+    return reply.code(404).send({ ok: false, error: message });
+}

package/dist/server.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+export interface StartServerOptions {
+    port?: number;
+    host?: string;
+    logger?: boolean;
+    installSignalHandlers?: boolean;
+}
+export declare const CLI_HELP = "Memorix Explorer static server\n\nUsage:\n  static-memorix [options]\n\nOptions:\n  --port <number>  Port to listen on (default: 5030)\n  --host <address> Host to bind (default: 0.0.0.0)\n  -h, --help       Show this help\n  -v, --version    Show the installed version\n\nEnvironment:\n  MOCKS_DIR         Writable JSON fixture directory\n  MEMORIX_ORG_ID    Organization routing ID\n  MEMORIX_AGENT_ID  Agent/Catalox routing ID\n\nExample:\n  static-memorix --port 5030\n";
+export declare function getPackageVersion(): string;
+export declare function parseCliArgs(args: string[]): StartServerOptions;
+export declare function isCliEntrypoint(argvPath: string | undefined, moduleUrl: string): boolean;
+/** Build a loaded Fastify instance without opening a network port. */
+export declare function buildServer(options?: Pick<StartServerOptions, "logger">): Promise<import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>>;
+/** Build and listen. Options override PORT/HOST environment configuration. */
+export declare function startServer(options?: StartServerOptions): Promise<import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>>;

package/dist/server.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import Fastify from "fastify";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { store } from "./storage/InMemoryStore.js";
+import { registerRoutes } from "./routes/index.js";
+import { PORT, HOST, MOCKS_DIR } from "./config.js";
+export const CLI_HELP = `Memorix Explorer static server
+
+Usage:
+  static-memorix [options]
+
+Options:
+  --port <number>  Port to listen on (default: 5030)
+  --host <address> Host to bind (default: 0.0.0.0)
+  -h, --help       Show this help
+  -v, --version    Show the installed version
+
+Environment:
+  MOCKS_DIR         Writable JSON fixture directory
+  MEMORIX_ORG_ID    Organization routing ID
+  MEMORIX_AGENT_ID  Agent/Catalox routing ID
+
+Example:
+  static-memorix --port 5030
+`;
+export function getPackageVersion() {
+    const packageFile = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
+    return JSON.parse(fs.readFileSync(packageFile, "utf8")).version;
+}
+export function parseCliArgs(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === "--port") {
+            const raw = args[++index];
+            const port = Number(raw);
+            if (!raw || !Number.isInteger(port) || port < 0 || port > 65535) {
+                throw Object.assign(new Error("--port must be an integer from 0 to 65535"), {
+                    statusCode: 400,
+                });
+            }
+            options.port = port;
+        }
+        else if (arg === "--host") {
+            const host = args[++index];
+            if (!host)
+                throw Object.assign(new Error("--host requires a value"), { statusCode: 400 });
+            options.host = host;
+        }
+        else {
+            throw Object.assign(new Error(`Unknown CLI argument: ${arg}`), { statusCode: 400 });
+        }
+    }
+    return options;
+}
+export function isCliEntrypoint(argvPath, moduleUrl) {
+    if (!argvPath)
+        return false;
+    try {
+        return fs.realpathSync(path.resolve(argvPath)) === fileURLToPath(moduleUrl);
+    }
+    catch {
+        return false;
+    }
+}
+/** Build a loaded Fastify instance without opening a network port. */
+export async function buildServer(options = {}) {
+    const app = Fastify({ logger: options.logger ?? false });
+    // Global error handler matching predictable error shapes.
+    app.setErrorHandler((error, _request, reply) => {
+        const normalized = error instanceof Error
+            ? error
+            : new Error("Internal Server Error");
+        const status = normalized.statusCode && normalized.statusCode >= 400
+            ? normalized.statusCode
+            : 500;
+        reply.status(status).send({
+            ok: false,
+            error: normalized.message || "Internal Server Error",
+        });
+    });
+    await store.load();
+    await registerRoutes(app);
+    return app;
+}
+/** Build and listen. Options override PORT/HOST environment configuration. */
+export async function startServer(options = {}) {
+    const app = await buildServer(options);
+    const port = options.port ?? PORT;
+    const host = options.host ?? HOST;
+    await app.listen({ port, host });
+    const address = app.server.address();
+    const boundPort = typeof address === "object" && address ? address.port : port;
+    const displayHost = host === "0.0.0.0" ? "localhost" : host;
+    // eslint-disable-next-line no-console
+    console.log(`\nMemorix Explorer is ready`);
+    console.log(`  Demo:   http://${displayHost}:${boundPort}/demo`);
+    console.log(`  API:    http://${displayHost}:${boundPort}/api/explorer`);
+    console.log(`  Health: http://${displayHost}:${boundPort}/health`);
+    console.log(`  JSON:   ${MOCKS_DIR}\n`);
+    if (options.installSignalHandlers ?? true) {
+        const shutdown = async () => {
+            console.log("\n[static-memorix] flushing + shutting down");
+            await store.flushAll();
+            await app.close();
+            process.exit(0);
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    }
+    return app;
+}
+const isCliEntry = isCliEntrypoint(process.argv[1], import.meta.url);
+if (isCliEntry) {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(CLI_HELP);
+    }
+    else if (args.includes("--version") || args.includes("-v")) {
+        console.log(getPackageVersion());
+    }
+    else
+        Promise.resolve().then(() => startServer(parseCliArgs(args))).catch((err) => {
+            // eslint-disable-next-line no-console
+            console.error(err);
+            process.exit(1);
+        });
+}

package/dist/storage/InMemoryStore.d.ts

@@ -0,0 +1,31 @@
+import { type ContentType } from "../types.js";
+export declare class InMemoryStore {
+    private collections;
+    private metadata;
+    private flushTimers;
+    private loaded;
+    /**
+     * Load everything from disk into memory. Idempotent.
+     */
+    load(): Promise<void>;
+    private loadMetadataCatalog;
+    private loadDataCollections;
+    getMeta<T = any>(key: string): T | undefined;
+    setMeta(key: string, data: any, persist?: boolean): void;
+    /** Persist a routed tombstone so an unprefixed seed does not reappear. */
+    deleteMeta(key: string): void;
+    getMetaKeys(): string[];
+    getCollection(objectType: string, ct: ContentType): any[];
+    setCollection(objectType: string, ct: ContentType, data: any[]): void;
+    getCollectionKeys(): string[];
+    private scheduleCollectionFlush;
+    private scheduleMetaFlush;
+    flushCollectionNow(key: string): void;
+    flushMetaNow(key: string): void;
+    /**
+     * Flush every dirty file immediately and clear timers.
+     */
+    flushAll(): Promise<void>;
+    get mocksDir(): string;
+}
+export declare const store: InMemoryStore;