@passelin/mock-bff 0.4.2

package/dist/cli.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { startServer } from "./server.js";
+function printHelp() {
+    console.log(`mock-bff - UI mock server from HAR/OpenAPI
+
+Usage:
+  mock-bff [options]
+
+Options:
+  -p, --port <number>         Server port (default: 8787)
+  -H, --host <host>           Server host (default: 0.0.0.0)
+  -r, --root <path>           Project root directory (default: cwd)
+  -a, --app-name <name>       App name label (default: local-app)
+      --provider <name>       AI provider: openai|anthropic|ollama|none (default: openai)
+      --model <id>            AI model id (provider-specific)
+      --openai-base-url <url> OpenAI-compatible base URL override for OpenAI provider
+      --anthropic-base-url <url> Anthropic base URL override
+      --ollama-base-url <url> Ollama base URL (default: http://127.0.0.1:11434)
+  -h, --help                  Show help
+
+Environment:
+  OPENAI_API_KEY              Required when --provider openai
+  ANTHROPIC_API_KEY           Required when --provider anthropic
+  OPENAI_BASE_URL             Optional OpenAI base URL override
+  ANTHROPIC_BASE_URL          Optional Anthropic base URL override
+  OLLAMA_BASE_URL             Optional Ollama base URL override (default http://127.0.0.1:11434)
+  MOCK_MAX_UPLOAD_BYTES       Multipart upload limit bytes (default: 250MB)
+`);
+}
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        const eat = () => {
+            i += 1;
+            return next;
+        };
+        if (a === "-h" || a === "--help")
+            out.help = true;
+        else if (a === "-p" || a === "--port")
+            out.port = eat();
+        else if (a === "-H" || a === "--host")
+            out.host = eat();
+        else if (a === "-r" || a === "--root")
+            out.root = eat();
+        else if (a === "-a" || a === "--app-name")
+            out.appName = eat();
+        else if (a === "--provider")
+            out.provider = eat();
+        else if (a === "--model")
+            out.model = eat();
+        else if (a === "--openai-base-url")
+            out.openaiBaseUrl = eat();
+        else if (a === "--anthropic-base-url")
+            out.anthropicBaseUrl = eat();
+        else if (a === "--ollama-base-url")
+            out.ollamaBaseUrl = eat();
+        else
+            throw new Error(`Unknown option: ${a}`);
+    }
+    return out;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    if (args.provider)
+        process.env.MOCK_AI_PROVIDER = String(args.provider);
+    if (args.model)
+        process.env.MOCK_AI_MODEL = String(args.model);
+    if (args.openaiBaseUrl)
+        process.env.OPENAI_BASE_URL = String(args.openaiBaseUrl);
+    if (args.anthropicBaseUrl)
+        process.env.ANTHROPIC_BASE_URL = String(args.anthropicBaseUrl);
+    if (args.ollamaBaseUrl)
+        process.env.OLLAMA_BASE_URL = String(args.ollamaBaseUrl);
+    const rootDir = args.root ? path.resolve(String(args.root)) : process.cwd();
+    const { host, port } = await startServer({
+        host: args.host ? String(args.host) : undefined,
+        port: args.port ? Number(args.port) : undefined,
+        appName: args.appName ? String(args.appName) : undefined,
+        rootDir,
+    });
+    console.log(`mock-bff running at http://${host}:${port}`);
+    console.log(`admin ui: http://${host}:${port}/-/admin`);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/har.js

@@ -0,0 +1,106 @@
+import { buildVariantName } from "./matcher.js";
+import { normalizePath, normalizeQuery, redactHeaders, redactJsonValue, shortHash } from "./utils.js";
+const DROPPED_INGEST_HEADERS = new Set([
+    "content-encoding",
+    "content-length",
+    "transfer-encoding",
+    "connection",
+    // let Fastify CORS plugin own these at runtime
+    "access-control-allow-origin",
+    "access-control-allow-methods",
+    "access-control-allow-headers",
+    "access-control-allow-credentials",
+    "access-control-expose-headers",
+    "access-control-max-age",
+    "access-control-request-method",
+    "access-control-request-headers",
+    "vary",
+]);
+function toHeaderMap(headers = []) {
+    const out = {};
+    for (const h of headers) {
+        const key = h.name.toLowerCase();
+        if (DROPPED_INGEST_HEADERS.has(key))
+            continue;
+        out[key] = h.value;
+    }
+    return out;
+}
+function maybeJson(text) {
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function globToRegExp(glob) {
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`, "i");
+}
+export function isApiLikeRequest(args) {
+    const method = args.method.toUpperCase();
+    const pathname = normalizePath(args.pathname).toLowerCase();
+    const mime = (args.responseMimeType ?? '').toLowerCase();
+    const requireJson = args.requireJsonResponse ?? args.config.har.requireJsonResponse;
+    if (!args.config.har.onlyApiCalls)
+        return true;
+    if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method))
+        return false;
+    if (args.config.har.excludeExtensions.some((ext) => pathname.endsWith(ext.toLowerCase())))
+        return false;
+    if (args.config.har.pathAllowlist.length > 0 && !args.config.har.pathAllowlist.some((p) => pathname.includes(p.toLowerCase()))) {
+        return false;
+    }
+    if (args.config.har.pathDenylist.some((p) => pathname.includes(p.toLowerCase())))
+        return false;
+    if (args.config.har.ignorePatterns.some((g) => globToRegExp(g).test(pathname)))
+        return false;
+    if (requireJson && !mime.includes("application/json"))
+        return false;
+    return true;
+}
+function shouldKeepEntry(entry, config) {
+    const url = entry._urlObj ?? new URL(entry.request.url);
+    return isApiLikeRequest({
+        method: entry.request.method,
+        pathname: url.pathname,
+        config,
+        responseMimeType: entry.response.content?.mimeType,
+        requireJsonResponse: config.har.requireJsonResponse,
+    });
+}
+export function parseHar(input, config) {
+    const data = JSON.parse(input);
+    const entries = (data.log?.entries ?? []).map((e) => ({ ...e, _urlObj: new URL(e.request.url) }));
+    const filtered = entries.filter((e) => shouldKeepEntry(e, config));
+    return filtered.map((e) => {
+        const url = e._urlObj ?? new URL(e.request.url);
+        const method = e.request.method.toUpperCase();
+        const path = normalizePath(url.pathname);
+        const rawQuery = Object.fromEntries((e.request.queryString ?? []).map((q) => [q.name, q.value]));
+        const queryObj = normalizeQuery(rawQuery, config.ignoredQueryParams);
+        const reqBody = redactJsonValue(maybeJson(e.request.postData?.text), config.redactBodyKeys);
+        const resBody = redactJsonValue(maybeJson(e.response.content?.text), config.redactBodyKeys);
+        const resHeaders = redactHeaders(toHeaderMap(e.response.headers), config.redactHeaders);
+        const variant = buildVariantName(queryObj, reqBody);
+        return {
+            method,
+            path,
+            variant,
+            mock: {
+                requestSignature: {
+                    method,
+                    path,
+                    queryHash: shortHash(JSON.stringify(queryObj)),
+                    bodyHash: shortHash(JSON.stringify(reqBody)),
+                },
+                requestSnapshot: { query: queryObj, body: reqBody },
+                response: { status: e.response.status, headers: resHeaders, body: resBody },
+                meta: { source: "har", createdAt: new Date().toISOString() },
+            },
+        };
+    });
+}

package/dist/matcher.js

@@ -0,0 +1,41 @@
+import { canonicalize, shortHash } from "./utils.js";
+export function buildVariantName(query, body) {
+    const q = canonicalize(query);
+    const b = canonicalize(body);
+    return `q_${q ? shortHash(q) : "empty"}__b_${b ? shortHash(b) : "empty"}`;
+}
+function objectKeys(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return new Set();
+    return new Set(Object.keys(value));
+}
+function scoreCandidate(requestBody, candidateBody) {
+    const reqKeys = objectKeys(requestBody);
+    const candKeys = objectKeys(candidateBody);
+    if (reqKeys.size === 0 || candKeys.size === 0)
+        return 0;
+    let overlap = 0;
+    for (const key of reqKeys) {
+        if (candKeys.has(key))
+            overlap += 1;
+    }
+    return overlap / Math.max(reqKeys.size, candKeys.size);
+}
+export function matchMock(args) {
+    if (args.exact)
+        return { type: "exact", mock: args.exact };
+    let best;
+    let bestScore = 0;
+    for (const v of args.variants) {
+        const score = scoreCandidate(args.requestBody, v.requestSnapshot?.body);
+        if (score > bestScore) {
+            best = v;
+            bestScore = score;
+        }
+    }
+    if (best && bestScore >= 0.4)
+        return { type: "fuzzy", mock: best };
+    if (args.defaultMock)
+        return { type: "default", mock: args.defaultMock };
+    return { type: "miss" };
+}

package/dist/openapi.js

@@ -0,0 +1,116 @@
+import { readFile } from "node:fs/promises";
+import { load } from "js-yaml";
+import AjvImport from "ajv";
+const AjvCtor = AjvImport.default ?? AjvImport;
+const ajv = new AjvCtor({ allErrors: true, strict: false });
+function getByPointer(root, pointer) {
+    const parts = pointer.replace(/^#\//, '').split('/').filter(Boolean).map((p) => p.replace(/~1/g, '/').replace(/~0/g, '~'));
+    let cur = root;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object' || !(p in cur))
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function resolveRefs(schema, root, seen = new Set()) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map((x) => resolveRefs(x, root, seen));
+    const obj = schema;
+    if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#/')) {
+        const ref = obj.$ref;
+        if (seen.has(ref))
+            return schema;
+        const target = getByPointer(root, ref);
+        if (!target)
+            return schema;
+        const nextSeen = new Set(seen);
+        nextSeen.add(ref);
+        const resolved = resolveRefs(target, root, nextSeen);
+        const merged = { ...resolved, ...Object.fromEntries(Object.entries(obj).filter(([k]) => k !== '$ref')) };
+        return resolveRefs(merged, root, nextSeen);
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (k === 'nullable' && v === true)
+            continue;
+        out[k] = resolveRefs(v, root, seen);
+    }
+    if (obj.nullable === true && typeof out.type === 'string') {
+        out.type = [out.type, 'null'];
+    }
+    return out;
+}
+export async function loadOpenApiFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        if (filePath.endsWith(".yaml") || filePath.endsWith(".yml"))
+            return load(raw);
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizePath(pathname) {
+    return pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+}
+export function findPathKey(doc, runtimePath) {
+    if (!doc.paths)
+        return undefined;
+    const target = normalizePath(runtimePath);
+    for (const key of Object.keys(doc.paths)) {
+        const re = new RegExp(`^${key.replace(/\{[^/]+\}/g, "[^/]+")}$`);
+        if (re.test(target))
+            return key;
+    }
+    return undefined;
+}
+export function buildOpenApiHint(args) {
+    if (!args.doc?.paths)
+        return undefined;
+    const matchedPath = findPathKey(args.doc, args.path);
+    if (!matchedPath)
+        return undefined;
+    const methodDef = args.doc.paths[matchedPath]?.[args.method.toLowerCase()];
+    if (!methodDef)
+        return undefined;
+    const schema = methodDef.responses?.["200"]?.content?.["application/json"]?.schema ??
+        methodDef.responses?.["201"]?.content?.["application/json"]?.schema ??
+        methodDef.responses?.default?.content?.["application/json"]?.schema;
+    const resolved = schema ? resolveRefs(schema, args.doc) : undefined;
+    const schemaPreview = resolved ? JSON.stringify(resolved).slice(0, 3000) : "";
+    return [
+        `OpenAPI matched path: ${matchedPath}`,
+        methodDef.summary ? `OpenAPI summary: ${methodDef.summary}` : "",
+        methodDef.description ? `OpenAPI description: ${methodDef.description}` : "",
+        schemaPreview ? `OpenAPI response schema (application/json): ${schemaPreview}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function validateResponseWithOpenApi(args) {
+    if (!args.doc?.paths)
+        return { ok: true, errors: [] };
+    const matchedPath = findPathKey(args.doc, args.path);
+    if (!matchedPath)
+        return { ok: true, errors: [] };
+    const pathDef = args.doc.paths[matchedPath];
+    const methodDef = pathDef?.[args.method.toLowerCase()];
+    if (!methodDef)
+        return { ok: true, errors: [] };
+    const statusKey = String(args.status);
+    const resDef = methodDef.responses?.[statusKey] ?? methodDef.responses?.default;
+    const schema = resDef?.content?.["application/json"]?.schema;
+    if (!schema || typeof schema !== "object")
+        return { ok: true, errors: [] };
+    const resolvedSchema = resolveRefs(schema, args.doc);
+    const validate = ajv.compile(resolvedSchema);
+    const ok = validate(args.responseBody);
+    if (ok)
+        return { ok: true, errors: [] };
+    const errors = (validate.errors ?? []).map((e) => `${e.instancePath || "$"} ${e.message ?? "invalid"}`);
+    return { ok: false, errors };
+}

package/dist/server.js

@@ -0,0 +1,16 @@
+import "dotenv/config";
+import { createApp } from "./app.js";
+export async function startServer(opts = {}) {
+    const port = opts.port ?? Number(process.env.PORT || 8787);
+    const host = opts.host ?? process.env.HOST ?? "0.0.0.0";
+    const appName = opts.appName ?? process.env.MOCK_APP_NAME ?? "local-app";
+    const rootDir = opts.rootDir ?? process.env.MOCK_ROOT_DIR ?? process.cwd();
+    const app = await createApp({ rootDir, appName });
+    await app.listen({ port, host });
+    return { app, port, host };
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const { port, host } = await startServer();
+    console.log(`BFF Mock Server listening at http://${host}:${port}`);
+    console.log(`admin: http://${host}:${port}/-/admin`);
+}

package/dist/storage.js

@@ -0,0 +1,257 @@
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { safePathKey } from "./utils.js";
+const DEFAULT_CONFIG = {
+    appName: "app",
+    openApiMode: "assist",
+    aiEnabled: true,
+    aiProvider: "openai",
+    aiModel: "gpt-5.4-mini",
+    aiStorePrompt: false,
+    providerBaseUrls: {
+        openai: "https://api.openai.com/v1",
+        anthropic: "https://api.anthropic.com",
+        ollama: "http://127.0.0.1:11434",
+    },
+    aiPromptTemplate: `You are an HTTP server for a Single Page Application.
+Read the incoming HTTP request and return the most realistic successful HTTP response for a production-style REST API.
+
+Output requirements:
+1. Return exactly one JSON object with these top-level keys:
+ - \`status\`: number
+ - \`contentType\`: string (mime-type)
+ - \`body\`: JSON value or string (depending on content type)
+2. Do not include prose, commentary, explanations, or markdown.
+3. The response must always be a successful HTTP response (2xx only).
+
+Content negotiation:
+1. Inspect the \`Accept\` header to determine the response format.
+
+2. Default behavior (critical):
+ - If the \`Accept\` header resembles a typical browser request (e.g. includes multiple types like \`text/html\`, \`application/xhtml+xml\`, \`application/xml\`, \`image/*\`, \`*/*\`), treat it as NO explicit preference.
+ - In these cases, ALWAYS return \`application/json\`.
+ - If \`*/*\` is present, treat it as no preference and return JSON.
+
+3. Explicit format selection:
+ - Only return a non-JSON format (e.g. \`text/html\`) if:
+ - The \`Accept\` header specifies a single clear mime type, OR
+ - One mime type has a strictly higher q-value than all others and is not a wildcard.
+ - Examples that should return HTML:
+ - \`Accept: text/html\`
+ - \`Accept: text/html;q=1.0, application/json;q=0.5\`
+
+4. Ambiguous or browser-style headers:
+ - If multiple types are listed without a clear single winner (even if ordered), IGNORE ordering and return JSON.
+
+5. If the requested type is unsupported or unclear, default to \`application/json\`.
+
+6. For non-JSON responses (only when explicitly required), return a realistic representation (e.g. full HTML document as a string).
+
+7. Always set the \`Content-Type\` header accordingly.
+
+Response behavior:
+1. Follow standard REST conventions:
+ - \`POST\` creates a resource and returns the created entity.
+ - \`GET /collection\` returns an array.
+ - \`GET /collection/:id\` returns a single entity.
+ - \`PATCH\` partially updates fields and returns the updated entity.
+ - \`PUT\` replaces the entity and returns the replaced entity.
+ - \`DELETE\` returns \`204\` with \`body: null\` or a confirmation object.
+2. Support nested resources such as \`/users/:id/comments/:commentId\`.
+3. IDs must be unique and realistic.
+4. Timestamps must be realistic ISO-8601 strings.
+5. Prefer realistic defaults when information is missing.
+
+Conflict resolution:
+1. Always return a successful response (2xx). Never return 4xx or 5xx.
+2. If format expectations conflict, prioritize:
+ - Explicit \`Accept\` header rules (as defined above)
+ - Otherwise default to JSON
+
+Data modeling rules:
+1. Use the provided schema and endpoint hints whenever relevant.
+2. Preserve field names and types exactly as defined.
+3. Populate optional fields only when realistic.
+4. Keep generated values internally consistent.
+5. IDs should be unique numbers (random).
+6. Output VALID JSON ONLY. Do not add ellipsis or other non valid output.
+
+ADDITIONAL CONTEXT:
+
+{{context}}
+
+SIMILAR EXAMPLES:
+{{similar_examples_json}}
+
+THE REQUEST:
+
+Timestamp: {{datetime_iso}} 
+Method: {{method}}
+Path: {{path}}
+Query params: {{query_json}}
+Body: {{body_json}}
+Headers: {{headers_json}}`,
+    ignoredQueryParams: ["_", "cacheBust", "timestamp"],
+    redactHeaders: ["authorization", "cookie", "set-cookie", "x-api-key"],
+    redactBodyKeys: [
+        "password",
+        "token",
+        "accessToken",
+        "refreshToken",
+        "secret",
+        "apiKey",
+    ],
+    har: {
+        onlyApiCalls: true,
+        requireJsonResponse: true,
+        pathAllowlist: [],
+        pathDenylist: [],
+        ignorePatterns: [],
+        excludeExtensions: [
+            ".js",
+            ".css",
+            ".map",
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".webp",
+            ".svg",
+            ".ico",
+            ".woff",
+            ".woff2",
+            ".ttf",
+            ".eot",
+            ".pdf",
+        ],
+    },
+};
+export class MockStorage {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    metaDir() {
+        return path.join(this.rootDir, "_meta");
+    }
+    async ensureLayout() {
+        await mkdir(this.metaDir(), { recursive: true });
+        await this.writeConfig(await this.readConfig());
+        await this.writeIndex(await this.readIndex());
+        const contextPath = path.join(this.metaDir(), "context.md");
+        try {
+            await readFile(contextPath, "utf8");
+        }
+        catch {
+            await writeFile(contextPath, "", "utf8");
+        }
+    }
+    async readConfig() {
+        const file = path.join(this.metaDir(), "app.config.json");
+        try {
+            const parsed = JSON.parse(await readFile(file, "utf8"));
+            return {
+                ...DEFAULT_CONFIG,
+                ...parsed,
+                har: {
+                    ...DEFAULT_CONFIG.har,
+                    ...(parsed.har ?? {}),
+                },
+                providerBaseUrls: {
+                    ...DEFAULT_CONFIG.providerBaseUrls,
+                    ...(parsed.providerBaseUrls ?? {}),
+                },
+            };
+        }
+        catch {
+            return DEFAULT_CONFIG;
+        }
+    }
+    async writeConfig(config) {
+        await mkdir(this.metaDir(), { recursive: true });
+        await writeFile(path.join(this.metaDir(), "app.config.json"), JSON.stringify(config, null, 2), "utf8");
+    }
+    async readIndex() {
+        const file = path.join(this.metaDir(), "index.json");
+        try {
+            return JSON.parse(await readFile(file, "utf8"));
+        }
+        catch {
+            return [];
+        }
+    }
+    async writeIndex(entries) {
+        await writeFile(path.join(this.metaDir(), "index.json"), JSON.stringify(entries, null, 2), "utf8");
+    }
+    mockPath(method, apiPath, variantName) {
+        return path.join(this.rootDir, method.toUpperCase(), safePathKey(apiPath), "variants", `${variantName}.json`);
+    }
+    defaultPath(method, apiPath) {
+        return path.join(this.rootDir, method.toUpperCase(), safePathKey(apiPath), "default.json");
+    }
+    async saveVariant(method, apiPath, variantName, mock) {
+        const filePath = this.mockPath(method, apiPath, variantName);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, JSON.stringify(mock, null, 2), "utf8");
+        return filePath;
+    }
+    async saveDefault(method, apiPath, mock) {
+        const filePath = this.defaultPath(method, apiPath);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, JSON.stringify(mock, null, 2), "utf8");
+        return filePath;
+    }
+    async readMock(filePath) {
+        try {
+            return JSON.parse(await readFile(filePath, "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async listVariants(method, apiPath) {
+        const dir = path.join(this.rootDir, method.toUpperCase(), safePathKey(apiPath), "variants");
+        try {
+            const files = await readdir(dir);
+            return files
+                .filter((f) => f.endsWith(".json"))
+                .map((f) => path.join(dir, f));
+        }
+        catch {
+            return [];
+        }
+    }
+    async appendMiss(entry) {
+        await mkdir(this.metaDir(), { recursive: true });
+        await writeFile(path.join(this.metaDir(), "misses.log.jsonl"), `${JSON.stringify(entry)}\n`, { flag: "a" });
+    }
+    async clearMisses() {
+        await mkdir(this.metaDir(), { recursive: true });
+        await writeFile(path.join(this.metaDir(), "misses.log.jsonl"), "", "utf8");
+    }
+    async appendContext(text) {
+        await writeFile(path.join(this.metaDir(), "context.md"), `${text}\n`, {
+            flag: "a",
+        });
+    }
+    async clearEndpoint(method, apiPath) {
+        await rm(path.join(this.rootDir, method.toUpperCase(), safePathKey(apiPath)), { recursive: true, force: true });
+    }
+    async clearVariant(method, apiPath, variantId) {
+        await rm(this.mockPath(method, apiPath, variantId), { force: true });
+    }
+    async clearAllMocks() {
+        const entries = await readdir(this.rootDir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name === "_meta")
+                continue;
+            await rm(path.join(this.rootDir, entry.name), {
+                recursive: true,
+                force: true,
+            });
+        }
+        await this.writeIndex([]);
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};