@taicode/common-server 3.8.0 → 4.0.0-beta.1

package/output/app/define-server.negative-cases.js

@@ -0,0 +1,209 @@
+import { defineServer, startServer } from './entries.js';
+/**
+ * N2 §4 的 **15 条负向用例**：这些写法**必须编译失败**，全部由 `tsc --noEmit` 覆盖
+ * （**不进**运行期 vitest 断言）。
+ *
+ * 文件名刻意**不带** `.test.ts`：它由 `tsc --noEmit` 校验，不被 vitest 当作测试文件执行。
+ * 每个用例的 `@ts-expect-error` 必须**确有错误**，否则 tsc 会报「未使用」而失败。
+ *
+ * 说明：`defineServer` 的调用结果一律不用 —— 这些函数只作编译期证据。
+ */
+const identity = { service: 'negative-cases', title: 'Negative Cases', version: '1.0.0' };
+/** #1 `resources` 看不到 `config` */
+export function resourcesCannotSeeConfig() {
+    defineServer({
+        app: identity,
+        // @ts-expect-error `config` 不存在于 ResourcesContext
+        resources: ({ config }) => ({ config }),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #2 `resources` 看不到 `services` */
+export function resourcesCannotSeeServices() {
+    defineServer({
+        app: identity,
+        // @ts-expect-error `services` 不存在于 ResourcesContext
+        resources: ({ services }) => ({ services }),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #3 `config` 看不到 `services` */
+export function configCannotSeeServices() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: (ctx) => {
+            // @ts-expect-error `services` 不存在于 ConfigContext
+            void ctx.services;
+            return {};
+        },
+        services: () => ({}),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #4 `services` 看不到 `services`（禁 service 互依） */
+export function servicesCannotSeeServices() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: () => ({}),
+        services: (ctx) => {
+            // @ts-expect-error `services` 不存在于 ServiceContext（禁互依）
+            void ctx.services;
+            return {};
+        },
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #5 `routers` 看不到 `resources`（禁绕层直连数据层） */
+export function routersCannotSeeResources() {
+    defineServer({
+        app: identity,
+        resources: () => ({ database: {} }),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: () => [],
+        routers: (ctx) => {
+            // @ts-expect-error `resources` 不存在于 RouterContext
+            void ctx.resources.database;
+        },
+    });
+}
+/** #6 `routers` 看不到 `config` */
+export function routersCannotSeeConfig() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: () => [],
+        routers: (ctx) => {
+            // @ts-expect-error `config` 不存在于 RouterContext
+            void ctx.config;
+        },
+    });
+}
+/** #7 service 值声明 `dependsOn` → 该值塌成 `never` */
+export function serviceValueCannotDeclareDependsOn() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: () => ({}),
+        // @ts-expect-error `dependsOn` 声明使该值塌成 never
+        services: () => ({ a: { dependsOn: ['b'] } }),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #8 service 值是原始类型 → 被拒（防把配置塞进 services） */
+export function serviceValueCannotBePrimitive() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: () => ({}),
+        // @ts-expect-error 原始类型值被 ServicesShape 拒绝
+        services: () => ({ count: 1 }),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #9 `startServer` 只接受品牌产物，裸 `ServerConfig` 编译失败 */
+export function startServerRejectsBareConfig(bare) {
+    // @ts-expect-error 缺 `__brand`，不是 Server
+    void startServer(bare);
+}
+/** #10 `app.version` 必填 */
+export function appVersionIsRequired() {
+    defineServer({
+        // @ts-expect-error `AppIdentity.version` 必填
+        app: { service: 'no-version', title: 'No Version' },
+        resources: () => ({}),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #11 `cache: false` 静态关闭：键被 `Live<>` 从资源视图剔除 */
+export function staticallyDisabledResourceIsRemoved() {
+    defineServer({
+        app: identity,
+        resources: () => ({ cache: false, database: { query: () => '' } }),
+        config: (ctx) => {
+            // @ts-expect-error `cache: false` 的键已被 `Live<>` 剔除
+            void ctx.cache;
+            return {};
+        },
+        services: () => ({}),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #12 `config` 看不到 `app` */
+export function configCannotSeeApp() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: (ctx) => {
+            // @ts-expect-error `app` 不存在于 ConfigContext
+            void ctx.app;
+            return {};
+        },
+        services: () => ({}),
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}
+/** #13 `middlewares` 看不到 `resources`（中间件禁直连数据层） */
+export function middlewaresCannotSeeResources() {
+    defineServer({
+        app: identity,
+        resources: () => ({ database: {} }),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: (ctx) => {
+            // @ts-expect-error `resources` 不存在于 MiddlewareContext
+            void ctx.resources.database;
+            return [];
+        },
+        routers: () => undefined,
+    });
+}
+/** #14 `middlewares` 看不到 `env` */
+export function middlewaresCannotSeeEnv() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: () => ({}),
+        services: () => ({}),
+        middlewares: (ctx) => {
+            // @ts-expect-error `env` 不存在于 MiddlewareContext
+            void ctx.env;
+            return [];
+        },
+        routers: () => undefined,
+    });
+}
+/** #15 `services` 看不到 `env`（服务层禁读 env） */
+export function servicesCannotSeeEnv() {
+    defineServer({
+        app: identity,
+        resources: () => ({}),
+        config: () => ({}),
+        services: (ctx) => {
+            // @ts-expect-error `env` 不存在于 ServiceContext
+            void ctx.env.DATABASE_URL;
+            return {};
+        },
+        middlewares: () => [],
+        routers: () => undefined,
+    });
+}

package/output/app/define-server.test.js

@@ -1,299 +1,97 @@
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import { createPrismaDatabaseModule } from './database.js';
-import { defineServer } from './define-server.js';
-import { STEP_ORDER } from './steps.js';
-const P1_OPT_OUT = {
-    context: false,
-    response: false,
-    cors: false,
-    schema: false,
-    'rate-limit': false,
-    auth: false,
-    openapi: false,
-    database: false,
-};
-const DUMMY_ERRORS = {
-    UserError: class extends Error {
-    },
-    SystemError: class extends Error {
-    },
-};
-const TEST_CONFIG = { loadConfig: () => ({ debug: false, port: 0 }) };
-const FAKE_PRISMA_NAMESPACE = {
-    PrismaClientKnownRequestError: class extends Error {
-    },
-    PrismaClientUnknownRequestError: class extends Error {
-    },
-    PrismaClientValidationError: class extends Error {
-    },
-    PrismaClientRustPanicError: class extends Error {
-    },
-    PrismaClientInitializationError: class extends Error {
-    },
-};
-class FakeClient {
-    args;
-    disconnected = false;
-    constructor(args = []) {
-        this.args = args;
-    }
-    async $disconnect() {
-        this.disconnected = true;
-    }
-}
-function createTestLog() {
-    const steps = [];
-    const errors = [];
-    const log = {
-        debug: (obj) => {
-            const step = obj.step;
-            if (typeof step === 'string') {
-                steps.push(step);
-            }
-        },
-        info: () => undefined,
-        warn: () => undefined,
-        error: (obj) => {
-            errors.push(obj);
-        },
-    };
-    return { log, steps, errors };
-}
-function without(list, drop) {
-    return list.filter((step) => !drop.includes(step));
-}
-function createBaseOptions(overrides = {}) {
-    return {
-        serviceName: 'test',
-        title: 'Test',
-        description: 'Test service',
-        errors: DUMMY_ERRORS,
-        config: TEST_CONFIG,
-        modules: { ...P1_OPT_OUT },
-        serverOptions: { port: 0, host: '127.0.0.1' },
-        signal: false,
-        createServices: () => ({ dispose: () => undefined }),
-        registerRouters: () => undefined,
-        ...overrides,
-    };
-}
-describe('defineServer 装配期校验', () => {
-    it('未知模块名报错（文案逐字对齐 design §3.2）', async () => {
-        const modules = { ...P1_OPT_OUT, foo: false };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Unknown module "foo". Allowed: env, database, redis, context, response, cors, schema, rate-limit, auth, openapi');
-    });
-    it('重复注册报错', async () => {
-        const modules = { ...P1_OPT_OUT, cors: { name: 'cors' }, redis: { name: 'cors' } };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "cors" registered twice');
-    });
-    it('键名不符报错', async () => {
-        const modules = { ...P1_OPT_OUT, redis: { name: 'mysql' } };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module key "redis" != module.name "mysql"');
-    });
-    it('dependsOn 指向被跳过的模块报错', async () => {
-        const modules = {
-            ...P1_OPT_OUT,
-            database: false,
-            redis: { name: 'redis', dependsOn: ['database'] },
-        };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "redis" depends on "database" which is disabled');
-    });
-    it('P1 未实现模块未显式 false 报错', async () => {
-        const modules = {
-            context: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            auth: false,
-            openapi: false,
-            database: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "response" is not implemented until P3; pass false to opt out');
-    });
-    it('过渡期报错按真实阶段号：openapi = P2、auth = P4', async () => {
-        const modulesWithoutOpenapi = {
-            context: false,
-            response: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            auth: false,
-            database: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules: modulesWithoutOpenapi }))).rejects.toThrow('Module "openapi" is not implemented until P2; pass false to opt out');
-        const modulesWithoutAuth = {
-            context: false,
-            response: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            openapi: false,
-            database: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules: modulesWithoutAuth }))).rejects.toThrow('Module "auth" is not implemented until P4; pass false to opt out');
-    });
-    it('未显式提供 database 报错（提示需 createPrismaDatabaseModule({...}) 或 false）', async () => {
-        const modules = {
-            context: false,
-            response: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            auth: false,
-            openapi: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "database" requires createPrismaDatabaseModule({...}) or false');
-    });
-    it('装配期报错发生在 promise resolve 之前（不拖到 listen）', async () => {
-        const promise = defineServer(createBaseOptions({ modules: { ...P1_OPT_OUT, database: false, redis: { name: 'redis', dependsOn: ['database'] } } }));
-        await expect(promise).rejects.toThrow();
-    });
-});
-describe('defineServer 15 步骨架', () => {
-    it('production 模式执行完整 15 步且顺序固定', async () => {
-        const { log, steps } = createTestLog();
-        const app = await defineServer(createBaseOptions({ log, mode: 'production' }));
-        try {
-            expect(steps).toEqual([...STEP_ORDER]);
-        }
-        finally {
-            await app.close();
-        }
-    });
-    it('test 模式跳过第 10 / 14 步', async () => {
-        const { log, steps } = createTestLog();
-        const app = await defineServer(createBaseOptions({ log, mode: 'test' }));
-        try {
-            expect(steps).toEqual(without(STEP_ORDER, ['backgroundWorkers', 'afterReady']));
-        }
-        finally {
-            await app.close();
-        }
-    });
-    it('openapi-build 模式跳过 [5,6,9,10,14,15]，但保留第 3 / 4 步（决策 10-3）', async () => {
-        const { log, steps } = createTestLog();
-        const app = await defineServer(createBaseOptions({ log, mode: 'openapi-build' }));
-        expect(steps).toEqual(without(STEP_ORDER, ['initGlobalConfig', 'initClients', 'initServices', 'backgroundWorkers', 'afterReady', 'listen']));
-        expect(steps).toContain('database.createClient');
-        expect(steps).toContain('createRedis');
-        await app.close();
-    });
-});
-describe('defineServer 跳过语义', () => {
-    it('test 模式下 backgroundWorkers / afterReady 确实未执行', async () => {
-        let workers = 0;
-        let ready = 0;
-        const app = await defineServer(createBaseOptions({
-            mode: 'test',
-            backgroundWorkers: async () => {
-                workers += 1;
-            },
-            afterReady: async () => {
-                ready += 1;
-            },
-        }));
-        await app.close();
-        expect(workers).toBe(0);
-        expect(ready).toBe(0);
-    });
-    it('openapi-build 模式下连库/连 Redis 与集合类初始化确实未执行', async () => {
-        const calls = { initGlobalConfig: 0, initClients: 0, initServices: 0, workers: 0, ready: 0, routers: 0 };
-        const app = await defineServer(createBaseOptions({
-            mode: 'openapi-build',
-            initGlobalConfig: () => {
-                calls.initGlobalConfig += 1;
-            },
-            initClients: async () => {
-                calls.initClients += 1;
-            },
-            initServices: async () => {
-                calls.initServices += 1;
-            },
-            backgroundWorkers: async () => {
-                calls.workers += 1;
-            },
-            afterReady: async () => {
-                calls.ready += 1;
-            },
-            registerRouters: () => {
-                calls.routers += 1;
-            },
-        }));
-        await app.close();
-        expect(calls).toEqual({ initGlobalConfig: 0, initClients: 0, initServices: 0, workers: 0, ready: 0, routers: 1 });
-    });
-    it('production 模式下后台 worker / afterReady 都会执行', async () => {
-        let workers = 0;
-        let ready = 0;
-        const app = await defineServer(createBaseOptions({
-            mode: 'production',
-            backgroundWorkers: async () => {
-                workers += 1;
-            },
-            afterReady: async () => {
-                ready += 1;
-            },
-        }));
-        await app.close();
-        expect(workers).toBe(1);
-        expect(ready).toBe(1);
-    });
-    it('database: false 时第 3 步空转，createServices 收到 undefined db', async () => {
-        let received = 'sentinel';
-        const app = await defineServer(createBaseOptions({
-            modules: { ...P1_OPT_OUT, database: false },
-            createServices: (ctx) => {
-                received = ctx.db;
+import { defineServer, isServer, SERVER_BRAND, generateOpenApi } from './entries.js';
+/**
+ * `defineServer()`（N1 §1）——**纯定义**：产出一个 `Server` 对象，不建连、不起服务。
+ *
+ * 同一份定义可同时喂给「启动」与「出 spec」，这也是 `mode` 消失的原因。
+ */
+describe('defineServer 纯定义（N1 §1）', () => {
+    it('返回带品牌字段的 Server，并原样保留六个槽位', () => {
+        let resourcesCalls = 0;
+        const config = {
+            app: { service: 'define-server-test', title: 'Define Server Test', version: '1.0.0' },
+            resources: () => {
+                resourcesCalls += 1;
                 return {};
             },
-        }));
-        await app.close();
-        expect(received).toBeUndefined();
-    });
-});
-describe('defineServer 模块覆盖与 Db 推断', () => {
-    it('Db 泛型从 database 模块推断（决策 10-2，无需强转）', async () => {
-        const database = createPrismaDatabaseModule({
-            PrismaClient: FakeClient,
-            PrismaNamespace: FAKE_PRISMA_NAMESPACE,
+            config: () => ({ enabled: true }),
+            services: () => ({}),
+            middlewares: () => [],
+            routers: () => undefined,
+        };
+        const server = defineServer(config);
+        expect(server.__brand).toBe(SERVER_BRAND);
+        expect(server.app).toEqual({ service: 'define-server-test', title: 'Define Server Test', version: '1.0.0' });
+        expect(server.services).toBe(config.services);
+        expect(server.routers).toBe(config.routers);
+        // 纯定义：不跑任何工厂
+        expect(resourcesCalls).toBe(0);
+    });
+    it('isServer 只识别 defineServer 产物', () => {
+        const server = defineServer({
+            app: { service: 'is-server-test', title: 'Is Server Test', version: '1.0.0' },
+            resources: () => ({}),
+            config: () => ({}),
+            services: () => ({}),
+            middlewares: () => [],
+            routers: () => undefined,
         });
-        const app = await defineServer({
-            serviceName: 'test',
-            title: 'Test',
-            description: 'Test service',
-            errors: DUMMY_ERRORS,
-            config: TEST_CONFIG,
-            modules: { ...P1_OPT_OUT, database },
-            serverOptions: { port: 0, host: '127.0.0.1' },
-            signal: false,
-            createServices: (ctx) => {
-                expectTypeOf(ctx.db).toEqualTypeOf();
+        expect(isServer(server)).toBe(true);
+        expect(isServer({ __brand: 'other' })).toBe(false);
+        expect(isServer(null)).toBe(false);
+        expect(isServer('taicode.server')).toBe(false);
+    });
+    it('定义产物三入口共用：generateOpenApi 只读定义，不跑 config 槽位', async () => {
+        let configCalls = 0;
+        const server = defineServer({
+            app: { service: 'define-shared', title: 'Define Shared', version: '1.0.0' },
+            resources: () => ({}),
+            config: () => {
+                configCalls += 1;
                 return {};
             },
-            registerRouters: () => undefined,
+            services: () => ({}),
+            middlewares: () => [],
+            routers: () => undefined,
         });
-        await app.close();
-    });
-    it('整体覆盖 database 模块时使用覆盖实现的 createClient', async () => {
-        let created = 0;
-        const database = {
-            name: 'database',
-            createClient: () => {
-                created += 1;
-                return { tag: 'custom' };
+        await generateOpenApi(server);
+        expect(configCalls).toBe(0);
+    });
+    it('app.version 必填：缺 version 时 TypeScript 编译失败（无默认值）', () => {
+        // 纯类型约束：这里只靠 `tsc --noEmit` 校验。若 `version` 又变回可选，
+        // `@ts-expect-error` 会因「未使用」而报错，测试反而变红。
+        const build = () => ({
+            // @ts-expect-error 缺少必填 app.version
+            app: { service: 'missing-version', title: 'Missing Version' },
+            resources: () => ({}),
+            config: () => ({}),
+            services: () => ({}),
+            middlewares: () => [],
+            routers: () => undefined,
+        });
+        expect(build).toBeTypeOf('function');
+    });
+    it('R / C / S 全推导：middlewares 与 routers 的 ctx.services 是强类型实体（M5）', () => {
+        defineServer({
+            app: { service: 'infer', title: 'Infer', version: '1.0.0' },
+            resources: () => ({ database: { query: (sql) => sql } }),
+            config: ({ resources }) => ({ domain: resources.database.query('domain') }),
+            services: ({ resources, config }) => ({
+                user: {
+                    find: (id) => `${config.domain}:${resources.database.query(id)}`,
+                },
+            }),
+            middlewares: (ctx) => {
+                // 类型自证：ctx.services 是 services 的返回类型（不是 unknown）
+                expectTypeOf(ctx.services.user.find).toEqualTypeOf();
+                // 类型自证：ctx.config 是 config 的返回类型
+                expectTypeOf(ctx.config.domain).toEqualTypeOf();
+                return [];
             },
-            classifyError: () => null,
-        };
-        let received;
-        const app = await defineServer(createBaseOptions({
-            modules: { ...P1_OPT_OUT, database: database },
-            createServices: (ctx) => {
-                received = ctx.db;
-                return {};
+            routers: (ctx) => {
+                expectTypeOf(ctx.services.user.find).toEqualTypeOf();
+                ctx.app.get('/user', () => ({ name: ctx.services.user.find('1') }));
             },
-        }));
-        await app.close();
-        expect(created).toBe(1);
-        expect(received).toEqual({ tag: 'custom' });
+        });
     });
 });

package/output/app/entries.d.ts

@@ -0,0 +1,29 @@
+import type { OpenApiDocument, Server, ServerConfig, StartServerOptions } from './types.js';
+import type { FastifyInstance } from 'fastify';
+export { SERVER_BRAND } from './types.js';
+/**
+ * `defineServer()`（N1 §1）——**纯定义**：产出一个 `Server` 对象，不建连、不起服务。
+ *
+ * 启动是另一个函数（`startServer`）的事——同一份定义可同时喂给「启动」与「出 spec」
+ * （`generateOpenApi`）。调用方**不写泛型**：`R` / `C` / `S` 全部从工厂返回类型推导。
+ */
+export declare function defineServer<R, C, S>(config: ServerConfig<R, C, S>): Server<R, C, S>;
+/** 供内部/调试使用：判断是否为 `defineServer()` 产物 */
+export declare function isServer(value: unknown): value is Server<unknown, unknown, unknown>;
+/**
+ * `startServer()`——真正跑起来：构造资源、加载配置、建服务、装中间件、注册路由、listen、装信号。
+ *
+ * - 最早阶段**固定加载 env**（`.env.dev < .env < .env.local`；`ENV=test` 追加 `.env.test.local`）。
+ * - 返回**原生 `FastifyInstance`**：不包 `fastify-plugin`、不返回包装对象。
+ * - `listen` 默认 `NODE_ENV !== 'test'`（测试不监听）。
+ * - 硬性要求 `Server`（品牌）产物：传裸 `ServerConfig` 是编译错误。
+ */
+export declare function startServer<R, C, S>(server: Server<R, C, S>, options?: StartServerOptions<R, C, S>): Promise<FastifyInstance>;
+/**
+ * `generateOpenApi()`——只出 spec，跑到能拿到 schema 就停。
+ *
+ * **红线**：全程**不得要求配置有效** —— 不跑 `config` 槽位、不要求 `DATABASE_URL` / `REDIS_URL`
+ * 有效；`resources`（只构造不建连）/ `services` / 中间件注册 / 路由注册照常执行。
+ */
+export declare function generateOpenApi<R, C, S>(server: Server<R, C, S>): Promise<OpenApiDocument>;
+//# sourceMappingURL=entries.d.ts.map

package/output/app/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../source/app/entries.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAMpF;AAED,yCAAyC;AACzC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAMnF;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,GAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAavI;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAiBhG"}