@wopr-network/platform-core 1.68.0 → 1.69.0

package/dist/backup/types.d.ts

@@ -9,8 +9,8 @@ export type SnapshotTrigger = z.infer<typeof snapshotTriggerSchema>;
 /** Subscription tiers per WOP-440 */
 export declare const tierSchema: z.ZodEnum<{
     free: "free";
-    starter: "starter";
     pro: "pro";
+    starter: "starter";
     enterprise: "enterprise";
 }>;
 export type Tier = z.infer<typeof tierSchema>;

package/dist/server/__tests__/build-container.test.d.ts

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

package/dist/server/__tests__/build-container.test.js

@@ -0,0 +1,339 @@
+import { describe, expect, it, vi } from "vitest";
+// ---------------------------------------------------------------------------
+// Mocks — all class mocks use real classes (not arrow fns) so `new` works.
+// ---------------------------------------------------------------------------
+// Mock pg.Pool
+const mockPoolEnd = vi.fn().mockResolvedValue(undefined);
+const poolConstructorCalls = [];
+class MockPoolClass {
+    connectionString;
+    end = mockPoolEnd;
+    query = vi.fn().mockResolvedValue({ rows: [] });
+    constructor(opts) {
+        this.connectionString = opts.connectionString;
+        poolConstructorCalls.push(opts);
+    }
+}
+vi.mock("pg", () => ({ Pool: MockPoolClass }));
+// Mock drizzle db creation
+const mockDb = { __brand: "drizzle-db" };
+vi.mock("../../db/index.js", () => ({
+    createDb: vi.fn(() => mockDb),
+}));
+// Mock drizzle migrator
+const mockMigrate = vi.fn().mockResolvedValue(undefined);
+vi.mock("drizzle-orm/node-postgres/migrator", () => ({
+    migrate: mockMigrate,
+}));
+// Mock platformBoot
+const mockProductConfig = {
+    product: {
+        slug: "test",
+        brandName: "Test",
+        domain: "test.dev",
+        appDomain: "app.test.dev",
+        fromEmail: "hi@test.dev",
+        emailSupport: "support@test.dev",
+    },
+    navItems: [],
+    domains: [],
+    features: null,
+    fleet: null,
+    billing: null,
+};
+const mockPlatformBoot = vi.fn().mockResolvedValue({
+    service: {},
+    config: mockProductConfig,
+    corsOrigins: ["https://test.dev"],
+    seeded: false,
+});
+vi.mock("../../product-config/boot.js", () => ({
+    platformBoot: (...args) => mockPlatformBoot(...args),
+}));
+// Mock DrizzleLedger
+const mockSeedSystemAccounts = vi.fn().mockResolvedValue(undefined);
+class MockDrizzleLedgerClass {
+    seedSystemAccounts = mockSeedSystemAccounts;
+    balance = vi.fn().mockResolvedValue(0);
+    credit = vi.fn();
+    debit = vi.fn();
+    post = vi.fn();
+    hasReferenceId = vi.fn().mockResolvedValue(false);
+    history = vi.fn().mockResolvedValue([]);
+    tenantsWithBalance = vi.fn().mockResolvedValue([]);
+    memberUsage = vi.fn().mockResolvedValue([]);
+    lifetimeSpend = vi.fn().mockResolvedValue(0);
+    lifetimeSpendBatch = vi.fn().mockResolvedValue(new Map());
+    expiredCredits = vi.fn().mockResolvedValue([]);
+    trialBalance = vi.fn().mockResolvedValue({ balanced: true });
+    accountBalance = vi.fn().mockResolvedValue(0);
+    existsByReferenceIdLike = vi.fn().mockResolvedValue(false);
+    sumPurchasesForPeriod = vi.fn().mockResolvedValue(0);
+    getActiveTenantIdsInWindow = vi.fn().mockResolvedValue([]);
+    debitCapped = vi.fn().mockResolvedValue(null);
+}
+vi.mock("../../credits/ledger.js", async (importOriginal) => {
+    const orig = await importOriginal();
+    return { ...orig, DrizzleLedger: MockDrizzleLedgerClass };
+});
+// Mock org/tenancy
+class MockDrizzleOrgMemberRepositoryClass {
+    listMembers = vi.fn().mockResolvedValue([]);
+    addMember = vi.fn();
+}
+vi.mock("../../tenancy/org-member-repository.js", () => ({
+    DrizzleOrgMemberRepository: MockDrizzleOrgMemberRepositoryClass,
+}));
+class MockDrizzleOrgRepositoryClass {
+}
+vi.mock("../../tenancy/drizzle-org-repository.js", () => ({
+    DrizzleOrgRepository: MockDrizzleOrgRepositoryClass,
+}));
+const orgServiceConstructorCalls = [];
+class MockOrgServiceClass {
+    getOrCreatePersonalOrg = vi.fn();
+    constructor(...args) {
+        orgServiceConstructorCalls.push(args);
+    }
+}
+vi.mock("../../tenancy/org-service.js", () => ({
+    OrgService: MockOrgServiceClass,
+}));
+// Mock auth
+class MockBetterAuthUserRepositoryClass {
+}
+vi.mock("../../db/auth-user-repository.js", () => ({
+    BetterAuthUserRepository: MockBetterAuthUserRepositoryClass,
+}));
+class MockDrizzleUserRoleRepositoryClass {
+    isPlatformAdmin = vi.fn().mockResolvedValue(false);
+    listRolesByUser = vi.fn().mockResolvedValue([]);
+    getTenantIdByUserId = vi.fn().mockResolvedValue(null);
+    grantRole = vi.fn();
+    revokeRole = vi.fn().mockResolvedValue(false);
+    listUsersByRole = vi.fn().mockResolvedValue([]);
+}
+vi.mock("../../auth/user-role-repository.js", () => ({
+    DrizzleUserRoleRepository: MockDrizzleUserRoleRepositoryClass,
+}));
+// Mock fleet deps (only imported when fleet is enabled)
+class MockFleetManagerClass {
+    __brand = "fleet-manager";
+}
+vi.mock("../../fleet/fleet-manager.js", () => ({
+    FleetManager: MockFleetManagerClass,
+}));
+class MockProfileStoreClass {
+    __brand = "profile-store";
+}
+vi.mock("../../fleet/profile-store.js", () => ({
+    ProfileStore: MockProfileStoreClass,
+}));
+class MockProxyManagerClass {
+    __brand = "proxy-manager";
+}
+vi.mock("../../proxy/manager.js", () => ({
+    ProxyManager: MockProxyManagerClass,
+}));
+class MockDrizzleServiceKeyRepositoryClass {
+    __brand = "service-key-repo";
+}
+vi.mock("../../gateway/service-key-repository.js", () => ({
+    DrizzleServiceKeyRepository: MockDrizzleServiceKeyRepositoryClass,
+}));
+class MockDockerClass {
+    __brand = "docker";
+}
+vi.mock("dockerode", () => ({
+    default: MockDockerClass,
+}));
+// Mock crypto deps
+class MockDrizzleCryptoChargeRepositoryClass {
+    __brand = "charge-repo";
+}
+vi.mock("../../billing/crypto/charge-store.js", () => ({
+    DrizzleCryptoChargeRepository: MockDrizzleCryptoChargeRepositoryClass,
+}));
+class MockDrizzleWebhookSeenRepositoryClass {
+    __brand = "webhook-seen-repo";
+}
+vi.mock("../../billing/drizzle-webhook-seen-repository.js", () => ({
+    DrizzleWebhookSeenRepository: MockDrizzleWebhookSeenRepositoryClass,
+}));
+// Mock stripe deps
+class MockStripeClass {
+    __brand = "stripe-client";
+}
+vi.mock("stripe", () => ({
+    default: MockStripeClass,
+}));
+class MockDrizzleTenantCustomerRepositoryClass {
+    __brand = "tenant-customer-repo";
+}
+vi.mock("../../billing/stripe/tenant-store.js", () => ({
+    DrizzleTenantCustomerRepository: MockDrizzleTenantCustomerRepositoryClass,
+}));
+vi.mock("../../billing/stripe/credit-prices.js", () => ({
+    loadCreditPriceMap: vi.fn(() => new Map()),
+}));
+class MockStripePaymentProcessorClass {
+    __brand = "stripe-processor";
+    handleWebhook = vi.fn();
+}
+vi.mock("../../billing/stripe/stripe-payment-processor.js", () => ({
+    StripePaymentProcessor: MockStripePaymentProcessorClass,
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function baseBootConfig(overrides) {
+    return {
+        slug: "test-product",
+        databaseUrl: "postgres://localhost:5432/testdb",
+        provisionSecret: "test-secret",
+        features: {
+            fleet: false,
+            crypto: false,
+            stripe: false,
+            gateway: false,
+            hotPool: false,
+        },
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("buildContainer", () => {
+    // Dynamic import so mocks are registered before the module loads
+    async function loadBuildContainer() {
+        const mod = await import("../container.js");
+        return mod.buildContainer;
+    }
+    it("throws on empty databaseUrl", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({ databaseUrl: "" });
+        await expect(buildContainer(config)).rejects.toThrow("databaseUrl is required");
+    });
+    it("creates pool with correct connectionString", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig();
+        poolConstructorCalls.length = 0;
+        const container = await buildContainer(config);
+        expect(poolConstructorCalls).toContainEqual({
+            connectionString: "postgres://localhost:5432/testdb",
+        });
+        expect(container.pool).toBeDefined();
+    });
+    it("calls platformBoot with correct slug", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({ slug: "paperclip" });
+        await buildContainer(config);
+        expect(mockPlatformBoot).toHaveBeenCalledWith(expect.objectContaining({ slug: "paperclip" }));
+    });
+    it("seeds system accounts after creating ledger", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig();
+        await buildContainer(config);
+        expect(mockSeedSystemAccounts).toHaveBeenCalled();
+    });
+    it("core services are always present", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig();
+        const container = await buildContainer(config);
+        expect(container.db).toBeDefined();
+        expect(container.pool).toBeDefined();
+        expect(container.productConfig).toBeDefined();
+        expect(container.creditLedger).toBeDefined();
+        expect(container.orgMemberRepo).toBeDefined();
+        expect(container.orgService).toBeDefined();
+        expect(container.userRoleRepo).toBeDefined();
+    });
+    it("returns null for all disabled features", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig();
+        const container = await buildContainer(config);
+        expect(container.fleet).toBeNull();
+        expect(container.crypto).toBeNull();
+        expect(container.stripe).toBeNull();
+        expect(container.gateway).toBeNull();
+        expect(container.hotPool).toBeNull();
+    });
+    it("builds fleet services when feature is enabled", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({
+            features: { fleet: true, crypto: false, stripe: false, gateway: false, hotPool: false },
+        });
+        const container = await buildContainer(config);
+        expect(container.fleet).not.toBeNull();
+        expect(container.fleet?.manager).toBeDefined();
+        expect(container.fleet?.docker).toBeDefined();
+        expect(container.fleet?.proxy).toBeDefined();
+        expect(container.fleet?.profileStore).toBeDefined();
+        expect(container.fleet?.serviceKeyRepo).toBeDefined();
+    });
+    it("builds crypto services when feature is enabled", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({
+            features: { fleet: false, crypto: true, stripe: false, gateway: false, hotPool: false },
+        });
+        const container = await buildContainer(config);
+        expect(container.crypto).not.toBeNull();
+        expect(container.crypto?.chargeRepo).toBeDefined();
+        expect(container.crypto?.webhookSeenRepo).toBeDefined();
+    });
+    it("builds stripe services when feature is enabled and key provided", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({
+            features: { fleet: false, crypto: false, stripe: true, gateway: false, hotPool: false },
+            stripeSecretKey: "sk_test_123",
+            stripeWebhookSecret: "whsec_test_456",
+        });
+        const container = await buildContainer(config);
+        expect(container.stripe).not.toBeNull();
+        expect(container.stripe?.stripe).toBeDefined();
+        expect(container.stripe?.webhookSecret).toBe("whsec_test_456");
+        expect(container.stripe?.customerRepo).toBeDefined();
+        expect(container.stripe?.processor).toBeDefined();
+    });
+    it("returns null stripe when feature enabled but no secret key", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({
+            features: { fleet: false, crypto: false, stripe: true, gateway: false, hotPool: false },
+            // stripeSecretKey intentionally omitted
+        });
+        const container = await buildContainer(config);
+        expect(container.stripe).toBeNull();
+    });
+    it("builds gateway services when feature is enabled", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig({
+            features: { fleet: false, crypto: false, stripe: false, gateway: true, hotPool: false },
+        });
+        const container = await buildContainer(config);
+        expect(container.gateway).not.toBeNull();
+        expect(container.gateway?.serviceKeyRepo).toBeDefined();
+    });
+    it("runs migrations before building services", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig();
+        await buildContainer(config);
+        expect(mockMigrate).toHaveBeenCalled();
+        // Migration should be called before platformBoot
+        const migrateOrder = mockMigrate.mock.invocationCallOrder[0];
+        const bootOrder = mockPlatformBoot.mock.invocationCallOrder[0];
+        expect(migrateOrder).toBeLessThan(bootOrder);
+    });
+    it("constructs OrgService with orgRepo, memberRepo, db, and authUserRepo", async () => {
+        const buildContainer = await loadBuildContainer();
+        const config = baseBootConfig();
+        orgServiceConstructorCalls.length = 0;
+        await buildContainer(config);
+        expect(orgServiceConstructorCalls.length).toBeGreaterThan(0);
+        const [orgRepo, memberRepo, db, options] = orgServiceConstructorCalls[0];
+        expect(orgRepo).toBeInstanceOf(MockDrizzleOrgRepositoryClass);
+        expect(memberRepo).toBeInstanceOf(MockDrizzleOrgMemberRepositoryClass);
+        expect(db).toBe(mockDb);
+        expect(options).toEqual(expect.objectContaining({ userRepo: expect.any(MockBetterAuthUserRepositoryClass) }));
+    });
+});

package/dist/server/__tests__/container.test.d.ts

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

package/dist/server/__tests__/container.test.js

@@ -0,0 +1,170 @@
+import { describe, expect, it } from "vitest";
+import { createTestContainer } from "../test-container.js";
+// ---------------------------------------------------------------------------
+// PlatformContainer interface
+// ---------------------------------------------------------------------------
+describe("PlatformContainer", () => {
+    it("allows null feature services", () => {
+        const c = createTestContainer();
+        expect(c.fleet).toBeNull();
+        expect(c.crypto).toBeNull();
+        expect(c.stripe).toBeNull();
+        expect(c.gateway).toBeNull();
+        expect(c.hotPool).toBeNull();
+    });
+    it("requires core services to be present", () => {
+        const c = createTestContainer();
+        expect(c.db).toBeDefined();
+        expect(c.pool).toBeDefined();
+        expect(c.productConfig).toBeDefined();
+        expect(c.creditLedger).toBeDefined();
+        expect(c.orgMemberRepo).toBeDefined();
+        expect(c.orgService).toBeDefined();
+        expect(c.userRoleRepo).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// BootConfig shape
+// ---------------------------------------------------------------------------
+describe("BootConfig", () => {
+    it("requires slug and provisionSecret", () => {
+        const config = {
+            slug: "test-product",
+            databaseUrl: "postgres://localhost/test",
+            provisionSecret: "s3cret",
+            features: {
+                fleet: false,
+                crypto: false,
+                stripe: false,
+                gateway: false,
+                hotPool: false,
+            },
+        };
+        expect(config.slug).toBe("test-product");
+        expect(config.provisionSecret).toBe("s3cret");
+    });
+    it("accepts optional fields", () => {
+        const config = {
+            slug: "full",
+            databaseUrl: "postgres://localhost/full",
+            provisionSecret: "secret",
+            host: "127.0.0.1",
+            port: 4000,
+            features: {
+                fleet: true,
+                crypto: true,
+                stripe: true,
+                gateway: true,
+                hotPool: true,
+            },
+            stripeSecretKey: "sk_test_xxx",
+            stripeWebhookSecret: "whsec_xxx",
+            cryptoServiceKey: "csk_xxx",
+            routes: [],
+        };
+        expect(config.host).toBe("127.0.0.1");
+        expect(config.port).toBe(4000);
+        expect(config.features.fleet).toBe(true);
+    });
+    it("FeatureFlags has all five toggles", () => {
+        const flags = {
+            fleet: true,
+            crypto: false,
+            stripe: true,
+            gateway: false,
+            hotPool: true,
+        };
+        expect(Object.keys(flags)).toHaveLength(5);
+    });
+});
+// ---------------------------------------------------------------------------
+// createTestContainer
+// ---------------------------------------------------------------------------
+describe("createTestContainer", () => {
+    it("returns valid defaults", () => {
+        const c = createTestContainer();
+        expect(c.fleet).toBeNull();
+        expect(c.crypto).toBeNull();
+        expect(c.stripe).toBeNull();
+        expect(c.gateway).toBeNull();
+        expect(c.hotPool).toBeNull();
+        expect(c.productConfig.product).toBeDefined();
+    });
+    it("allows overrides for core services", () => {
+        const customConfig = {
+            product: { slug: "custom", name: "Custom" },
+            navItems: [],
+            domains: [],
+            features: null,
+            fleet: null,
+            billing: null,
+        };
+        const c = createTestContainer({ productConfig: customConfig });
+        expect(c.productConfig.product).toEqual({ slug: "custom", name: "Custom" });
+    });
+    it("stub ledger methods return sensible defaults", async () => {
+        const c = createTestContainer();
+        expect(await c.creditLedger.balance("t1")).toBe(0);
+        expect(await c.creditLedger.hasReferenceId("ref")).toBe(false);
+        expect(await c.creditLedger.history("t1")).toEqual([]);
+        expect(await c.creditLedger.tenantsWithBalance()).toEqual([]);
+        expect(await c.creditLedger.lifetimeSpendBatch([])).toEqual(new Map());
+    });
+    it("stub orgMemberRepo methods return sensible defaults", async () => {
+        const c = createTestContainer();
+        expect(await c.orgMemberRepo.findMember("org1", "u1")).toBeNull();
+        expect(await c.orgMemberRepo.listMembers("org1")).toEqual([]);
+        expect(await c.orgMemberRepo.countAdminsAndOwners("org1")).toBe(0);
+    });
+    it("stub userRoleRepo methods return sensible defaults", async () => {
+        const c = createTestContainer();
+        expect(await c.userRoleRepo.getTenantIdByUserId("u1")).toBeNull();
+        expect(await c.userRoleRepo.isPlatformAdmin("u1")).toBe(false);
+        expect(await c.userRoleRepo.listRolesByUser("u1")).toEqual([]);
+    });
+    it("allows enabling feature services via overrides", () => {
+        const fleet = {
+            manager: {},
+            docker: {},
+            proxy: {},
+            profileStore: {},
+            serviceKeyRepo: {},
+        };
+        const crypto = {
+            chargeRepo: {},
+            webhookSeenRepo: {},
+        };
+        const stripe = {
+            stripe: {},
+            webhookSecret: "whsec_test",
+            customerRepo: {},
+            processor: {},
+        };
+        const gateway = {
+            serviceKeyRepo: {},
+        };
+        const hotPool = {
+            poolManager: {},
+        };
+        const c = createTestContainer({ fleet, crypto, stripe, gateway, hotPool });
+        expect(c.fleet).not.toBeNull();
+        expect(c.crypto).not.toBeNull();
+        expect(c.stripe).not.toBeNull();
+        expect(c.stripe?.webhookSecret).toBe("whsec_test");
+        expect(c.gateway).not.toBeNull();
+        expect(c.hotPool).not.toBeNull();
+    });
+    it("overrides merge without affecting other defaults", () => {
+        const c = createTestContainer({ gateway: { serviceKeyRepo: {} } });
+        // Overridden field
+        expect(c.gateway).not.toBeNull();
+        // Other feature services remain null
+        expect(c.fleet).toBeNull();
+        expect(c.crypto).toBeNull();
+        expect(c.stripe).toBeNull();
+        expect(c.hotPool).toBeNull();
+        // Core services still present
+        expect(c.creditLedger).toBeDefined();
+        expect(c.orgMemberRepo).toBeDefined();
+    });
+});

package/dist/server/__tests__/lifecycle.test.d.ts

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

package/dist/server/__tests__/lifecycle.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from "vitest";
+import { gracefulShutdown, startBackgroundServices } from "../lifecycle.js";
+import { createTestContainer } from "../test-container.js";
+describe("startBackgroundServices", () => {
+    it("returns a BackgroundHandles object", async () => {
+        const container = createTestContainer();
+        const handles = await startBackgroundServices(container);
+        expect(handles).toHaveProperty("intervals");
+        expect(handles).toHaveProperty("unsubscribes");
+        expect(Array.isArray(handles.intervals)).toBe(true);
+        expect(Array.isArray(handles.unsubscribes)).toBe(true);
+    });
+    it("calls proxy.start when fleet is enabled", async () => {
+        const startFn = vi.fn().mockResolvedValue(undefined);
+        const container = createTestContainer({
+            fleet: {
+                manager: {},
+                docker: {},
+                proxy: {
+                    start: startFn,
+                    addRoute: async () => { },
+                    removeRoute: () => { },
+                    getRoutes: () => [],
+                },
+                profileStore: { list: async () => [] },
+                serviceKeyRepo: {},
+            },
+        });
+        await startBackgroundServices(container);
+        expect(startFn).toHaveBeenCalledOnce();
+    });
+    it("does not throw when proxy.start fails", async () => {
+        const container = createTestContainer({
+            fleet: {
+                manager: {},
+                docker: {},
+                proxy: {
+                    start: async () => {
+                        throw new Error("proxy start failed");
+                    },
+                    addRoute: async () => { },
+                    removeRoute: () => { },
+                    getRoutes: () => [],
+                },
+                profileStore: { list: async () => [] },
+                serviceKeyRepo: {},
+            },
+        });
+        // Should not throw
+        const handles = await startBackgroundServices(container);
+        expect(handles).toBeDefined();
+    });
+});
+describe("gracefulShutdown", () => {
+    it("clears all intervals", async () => {
+        const container = createTestContainer();
+        const clearSpy = vi.spyOn(global, "clearInterval");
+        const interval1 = setInterval(() => { }, 10000);
+        const interval2 = setInterval(() => { }, 10000);
+        const handles = {
+            intervals: [interval1, interval2],
+            unsubscribes: [],
+        };
+        await gracefulShutdown(container, handles);
+        expect(clearSpy).toHaveBeenCalledWith(interval1);
+        expect(clearSpy).toHaveBeenCalledWith(interval2);
+        clearSpy.mockRestore();
+    });
+    it("calls all unsubscribe functions", async () => {
+        const container = createTestContainer();
+        const unsub1 = vi.fn();
+        const unsub2 = vi.fn();
+        const handles = {
+            intervals: [],
+            unsubscribes: [unsub1, unsub2],
+        };
+        await gracefulShutdown(container, handles);
+        expect(unsub1).toHaveBeenCalledOnce();
+        expect(unsub2).toHaveBeenCalledOnce();
+    });
+    it("calls pool.end()", async () => {
+        const endFn = vi.fn().mockResolvedValue(undefined);
+        const container = createTestContainer({
+            pool: { end: endFn },
+        });
+        const handles = { intervals: [], unsubscribes: [] };
+        await gracefulShutdown(container, handles);
+        expect(endFn).toHaveBeenCalledOnce();
+    });
+});

package/dist/server/__tests__/mount-routes.test.d.ts

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