@prisma-next/emitter 0.3.0-dev.9 → 0.3.0-dev.91

package/test/emitter.integration.test.ts

@@ -128,7 +128,7 @@ describe('emitter integration', () => {
 
       const result = await emit(ir, options, mockSqlHook);
 
-      expect(result.coreHash).toMatch(/^sha256:[a-f0-9]{64}$/);
+      expect(result.storageHash).toMatch(/^sha256:[a-f0-9]{64}$/);
       expect(result.contractDts).toContain('export type Contract');
       expect(result.contractDts).toContain('CodecTypes');
       expect(result.contractDts).toContain('LaneCodecTypes');
@@ -138,7 +138,7 @@ describe('emitter integration', () => {
         schemaVersion: '1',
         targetFamily: 'sql',
         target: 'postgres',
-        coreHash: result.coreHash,
+        storageHash: result.storageHash,
         storage: {
           tables: {
             user: expect.anything(),
@@ -197,78 +197,82 @@ describe('emitter integration', () => {
     const result1 = await emit(ir, options, mockSqlHook);
     const result2 = await emit(ir, options, mockSqlHook);
 
-    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.storageHash).toBe(result2.storageHash);
     expect(result1.contractDts).toBe(result2.contractDts);
     expect(result1.contractJson).toBe(result2.contractJson);
   });
 
-  it('round-trip: IR → JSON → parse JSON → compare', async () => {
-    const ir = createContractIR({
-      models: {
-        User: {
-          storage: { table: 'user' },
-          fields: {
-            id: { column: 'id' },
-            email: { column: 'email' },
+  it(
+    'round-trip: IR → JSON → parse JSON → compare',
+    async () => {
+      const ir = createContractIR({
+        models: {
+          User: {
+            storage: { table: 'user' },
+            fields: {
+              id: { column: 'id' },
+              email: { column: 'email' },
+            },
+            relations: {},
           },
-          relations: {},
         },
-      },
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-              email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+        storage: {
+          tables: {
+            user: {
+              columns: {
+                id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+                email: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              },
+              primaryKey: { columns: ['id'] },
+              uniques: [],
+              indexes: [],
+              foreignKeys: [],
             },
-            primaryKey: { columns: ['id'] },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
           },
         },
-      },
-      extensionPacks: {
-        postgres: {
-          version: '0.0.1',
+        extensionPacks: {
+          postgres: {
+            version: '0.0.1',
+          },
+          pg: {},
         },
-        pg: {},
-      },
-    });
+      });
 
-    // Create minimal test data (emitter tests don't load packs)
-    const operationRegistry = createOperationRegistry();
-    const codecTypeImports: TypesImportSpec[] = [];
-    const operationTypeImports: TypesImportSpec[] = [];
-    const extensionIds = ['postgres', 'pg'];
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports,
-      operationTypeImports,
-      extensionIds,
-    };
+      // Create minimal test data (emitter tests don't load packs)
+      const operationRegistry = createOperationRegistry();
+      const codecTypeImports: TypesImportSpec[] = [];
+      const operationTypeImports: TypesImportSpec[] = [];
+      const extensionIds = ['postgres', 'pg'];
+      const options: EmitOptions = {
+        outputDir: '',
+        operationRegistry,
+        codecTypeImports,
+        operationTypeImports,
+        extensionIds,
+      };
 
-    const result1 = await emit(ir, options, mockSqlHook);
-    const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
+      const result1 = await emit(ir, options, mockSqlHook);
+      const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
 
-    const ir2 = createContractIR({
-      schemaVersion: contractJson1['schemaVersion'] as string,
-      targetFamily: contractJson1['targetFamily'] as string,
-      target: contractJson1['target'] as string,
-      models: contractJson1['models'] as Record<string, unknown>,
-      relations: (contractJson1['relations'] as Record<string, unknown>) || {},
-      storage: contractJson1['storage'] as Record<string, unknown>,
-      extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
-      capabilities:
-        (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
-      meta: (contractJson1['meta'] as Record<string, unknown>) || {},
-      sources: (contractJson1['sources'] as Record<string, unknown>) || {},
-    });
+      const ir2 = createContractIR({
+        schemaVersion: contractJson1['schemaVersion'] as string,
+        targetFamily: contractJson1['targetFamily'] as string,
+        target: contractJson1['target'] as string,
+        models: contractJson1['models'] as Record<string, unknown>,
+        relations: (contractJson1['relations'] as Record<string, unknown>) || {},
+        storage: contractJson1['storage'] as Record<string, unknown>,
+        extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
+        capabilities:
+          (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
+        meta: (contractJson1['meta'] as Record<string, unknown>) || {},
+        sources: (contractJson1['sources'] as Record<string, unknown>) || {},
+      });
 
-    const result2 = await emit(ir2, options, mockSqlHook);
+      const result2 = await emit(ir2, options, mockSqlHook);
 
-    expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
-  });
+      expect(result1.contractJson).toBe(result2.contractJson);
+      expect(result1.storageHash).toBe(result2.storageHash);
+    },
+    timeouts.typeScriptCompilation,
+  );
 });

package/test/emitter.roundtrip.test.ts

@@ -133,7 +133,7 @@ describe('emitter round-trip', () => {
       const result2 = await emit(ir2, options, mockSqlHook);
 
       expect(result1.contractJson).toBe(result2.contractJson);
-      expect(result1.coreHash).toBe(result2.coreHash);
+      expect(result1.storageHash).toBe(result2.storageHash);
     },
     timeouts.typeScriptCompilation,
   );
@@ -230,7 +230,7 @@ describe('emitter round-trip', () => {
     const result2 = await emit(ir2, options, mockSqlHook);
 
     expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.storageHash).toBe(result2.storageHash);
   });
 
   it('round-trip with nullable fields', async () => {
@@ -289,7 +289,7 @@ describe('emitter round-trip', () => {
     const result2 = await emit(ir2, options, mockSqlHook);
 
     expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.storageHash).toBe(result2.storageHash);
 
     const parsed2 = JSON.parse(result2.contractJson) as Record<string, unknown>;
     const storage = parsed2['storage'] as Record<string, unknown>;
@@ -364,7 +364,7 @@ describe('emitter round-trip', () => {
     const result2 = await emit(ir2, options, mockSqlHook);
 
     expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.coreHash).toBe(result2.coreHash);
+    expect(result1.storageHash).toBe(result2.storageHash);
     expect(result1.profileHash).toBe(result2.profileHash);
   });
 });

package/test/emitter.test.ts

@@ -1,8 +1,9 @@
 import type { ContractIR } from '@prisma-next/contract/ir';
 import type {
+  GenerateContractTypesOptions,
   TargetFamilyHook,
+  TypeRenderEntry,
   TypesImportSpec,
-  ValidationContext,
 } from '@prisma-next/contract/types';
 import type { EmitOptions } from '@prisma-next/core-control-plane/emission';
 import { emit } from '@prisma-next/core-control-plane/emission';
@@ -13,7 +14,7 @@ import { createContractIR } from './utils';
 
 const mockSqlHook: TargetFamilyHook = {
   id: 'sql',
-  validateTypes: (ir: ContractIR, _ctx: ValidationContext) => {
+  validateTypes: (ir: ContractIR) => {
     const storage = ir.storage as
       | { tables?: Record<string, { columns?: Record<string, { codecId?: string }> }> }
       | undefined;
@@ -45,11 +46,12 @@ const mockSqlHook: TargetFamilyHook = {
       throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
     }
   },
-  generateContractTypes: (ir: ContractIR, _codecTypeImports, _operationTypeImports) => {
+  generateContractTypes: (ir: ContractIR, _codecTypeImports, _operationTypeImports, _hashes) => {
     // Access ir properties to satisfy lint rules, but we don't use them in the mock
     void ir;
     void _codecTypeImports;
     void _operationTypeImports;
+    void _hashes;
     return `// Generated contract types
 export type CodecTypes = Record<string, never>;
 export type LaneCodecTypes = CodecTypes;
@@ -109,7 +111,7 @@ describe('emitter', () => {
       };
 
       const result = await emit(ir, options, mockSqlHook);
-      expect(result.coreHash).toMatch(/^sha256:[a-f0-9]{64}$/);
+      expect(result.storageHash).toMatch(/^sha256:[a-f0-9]{64}$/);
       expect(result.contractDts).toContain('export type Contract');
       expect(result.contractDts).toContain('CodecTypes');
 
@@ -570,10 +572,12 @@ describe('emitter', () => {
     await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have meta');
   });
 
-  it('throws error when sources is missing', async () => {
+  it('omits sources from emitted contract artifact', async () => {
     const ir = createContractIR({
-      sources: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
+      sources: {
+        schema: { sourceId: 'schema.prisma' },
+      },
+    });
 
     const operationRegistry = createOperationRegistry();
     const options: EmitOptions = {
@@ -584,24 +588,68 @@ describe('emitter', () => {
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have sources');
+    const result = await emit(ir, options, mockSqlHook);
+    const contractJson = JSON.parse(result.contractJson) as Record<string, unknown>;
+    expect(contractJson).not.toHaveProperty('sources');
   });
 
-  it('throws error when sources is not an object', async () => {
+  it('accepts meta keys when family validation allows them', async () => {
     const ir = createContractIR({
-      sources: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
+      meta: {
+        sourceId: 'schema.prisma',
+        schemaPath: '/tmp/schema.prisma',
+        source: 'psl',
+      },
+    });
 
-    const operationRegistry = createOperationRegistry();
     const options: EmitOptions = {
       outputDir: '',
-      operationRegistry,
+      operationRegistry: createOperationRegistry(),
+      codecTypeImports: [],
+      operationTypeImports: [],
+      extensionIds: [],
+    };
+
+    await expect(emit(ir, options, mockSqlHook)).resolves.toMatchObject({
+      contractJson: expect.any(String),
+      contractDts: expect.any(String),
+    });
+  });
+
+  it('accepts canonical section keys when family validation allows them', async () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {
+          user: {
+            columns: {
+              id: {
+                codecId: 'pg/int4@1',
+                nativeType: 'int4',
+                nullable: false,
+                sourceId: 'schema.prisma',
+              },
+            },
+            primaryKey: { columns: ['id'] },
+            uniques: [],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      } as unknown as Record<string, unknown>,
+    });
+
+    const options: EmitOptions = {
+      outputDir: '',
+      operationRegistry: createOperationRegistry(),
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have sources');
+    await expect(emit(ir, options, mockSqlHook)).resolves.toMatchObject({
+      contractJson: expect.any(String),
+      contractDts: expect.any(String),
+    });
   });
 
   it('emits contract even when extensionIds are not in contract.extensionPacks', async () => {
@@ -623,9 +671,10 @@ describe('emitter', () => {
           throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
         }
       },
-      generateContractTypes: (_ir, _codecTypeImports, _operationTypeImports) => {
+      generateContractTypes: (_ir, _codecTypeImports, _operationTypeImports, _hashes) => {
         void _codecTypeImports;
         void _operationTypeImports;
+        void _hashes;
         return `// Generated contract types
 export type CodecTypes = Record<string, never>;
 export type LaneCodecTypes = CodecTypes;
@@ -647,4 +696,56 @@ export type Contract = unknown;
     expect(result.contractJson).toBeDefined();
     expect(result.contractDts).toBeDefined();
   });
+
+  it('passes parameterizedRenderers to generateContractTypes options', async () => {
+    const ir = createContractIR({
+      storage: {
+        tables: {},
+      },
+    });
+
+    let receivedOptions: GenerateContractTypesOptions | undefined;
+
+    const mockHookCapturingOptions: TargetFamilyHook = {
+      id: 'sql',
+      validateTypes: () => {},
+      validateStructure: () => {},
+      generateContractTypes: (_ir, _codecTypeImports, _operationTypeImports, _hashes, options) => {
+        receivedOptions = options;
+        return `// Generated contract types
+export type CodecTypes = Record<string, never>;
+export type LaneCodecTypes = CodecTypes;
+export type Contract = unknown;
+`;
+      },
+    };
+
+    const vectorRenderer: TypeRenderEntry = {
+      codecId: 'pg/vector@1',
+      render: (params) => `Vector<${params['length']}>`,
+    };
+
+    const parameterizedRenderers = new Map<string, TypeRenderEntry>();
+    parameterizedRenderers.set('pg/vector@1', vectorRenderer);
+
+    const options: EmitOptions = {
+      outputDir: '',
+      operationRegistry: createOperationRegistry(),
+      codecTypeImports: [],
+      operationTypeImports: [],
+      extensionIds: [],
+      parameterizedRenderers,
+    };
+
+    await emit(ir, options, mockHookCapturingOptions);
+
+    expect(receivedOptions).toBeDefined();
+    expect(receivedOptions?.parameterizedRenderers).toBeDefined();
+    expect(receivedOptions?.parameterizedRenderers?.size).toBe(1);
+
+    const entry = receivedOptions?.parameterizedRenderers?.get('pg/vector@1');
+    expect(entry).toBeDefined();
+    expect(entry?.codecId).toBe('pg/vector@1');
+    expect(entry?.render({ length: 1536 }, { codecTypesName: 'CodecTypes' })).toBe('Vector<1536>');
+  });
 });

package/test/factories.test.ts

@@ -7,13 +7,13 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
       });
       expect(header).toEqual({
         schemaVersion: '1',
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
       });
     });
 
@@ -21,14 +21,14 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
         profileHash: 'sha256:def456',
       });
       expect(header).toEqual({
         schemaVersion: '1',
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
         profileHash: 'sha256:def456',
       });
     });
@@ -37,7 +37,7 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'mongodb',
         targetFamily: 'document',
-        coreHash: 'sha256:xyz789',
+        storageHash: 'sha256:xyz789',
       });
       expect(header.targetFamily).toBe('document');
       expect(header.target).toBe('mongodb');
@@ -149,7 +149,7 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
       });
       const meta = irMeta({
         capabilities: {
@@ -171,7 +171,7 @@ describe('emitter factories', () => {
       expect(ir.schemaVersion).toBe('1');
       expect(ir.target).toBe('postgres');
       expect(ir.targetFamily).toBe('sql');
-      // Note: coreHash is not part of ContractIR (it's computed by emitter)
+      // Note: storageHash is not part of ContractIR (it's computed by emitter)
       expect(ir.storage).toEqual(storage);
       expect(ir.models).toEqual(models);
       expect(ir.relations).toEqual(relations);
@@ -187,7 +187,7 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
         profileHash: 'sha256:def456',
       });
       const meta = irMeta({});
@@ -213,7 +213,7 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'sha256:abc123',
+        storageHash: 'sha256:abc123',
       });
       const meta = irMeta({
         capabilities: {
@@ -251,7 +251,7 @@ describe('emitter factories', () => {
       const header = irHeader({
         target: 'mongodb',
         targetFamily: 'document',
-        coreHash: 'sha256:xyz789',
+        storageHash: 'sha256:xyz789',
       });
       const meta = irMeta({});
       const storage = { document: { collections: {} } };

package/test/hashing.test.ts

@@ -1,8 +1,8 @@
-import { computeCoreHash, computeProfileHash } from '@prisma-next/core-control-plane/emission';
+import { computeProfileHash, computeStorageHash } from '@prisma-next/core-control-plane/emission';
 import { describe, expect, it } from 'vitest';
 
 describe('hashing', () => {
-  it('computes core hash', () => {
+  it('computes storage hash', () => {
     const contract = {
       schemaVersion: '1',
       targetFamily: 'sql',
@@ -16,7 +16,7 @@ describe('hashing', () => {
       sources: {},
     };
 
-    const hash = computeCoreHash(contract);
+    const hash = computeStorageHash(contract);
     expect(hash).toMatch(/^sha256:[a-f0-9]{64}$/);
   });
 
@@ -52,8 +52,8 @@ describe('hashing', () => {
       sources: {},
     };
 
-    const hash1 = computeCoreHash(contract);
-    const hash2 = computeCoreHash(contract);
+    const hash1 = computeStorageHash(contract);
+    const hash2 = computeStorageHash(contract);
     expect(hash1).toBe(hash2);
   });
 });

package/test/utils.ts

@@ -9,12 +9,12 @@ import { type ContractIR, irHeader, irMeta } from '@prisma-next/contract/ir';
  * from the result (useful for testing validation of missing fields).
  */
 export function createContractIR(
-  overrides: Partial<ContractIR> & { coreHash?: string; profileHash?: string } = {},
+  overrides: Partial<ContractIR> & { storageHash?: string; profileHash?: string } = {},
 ): ContractIR {
   // Check if fields are explicitly undefined (not just missing)
   const hasTarget = 'target' in overrides;
   const hasTargetFamily = 'targetFamily' in overrides;
-  const hasCoreHash = 'coreHash' in overrides;
+  const hasStorageHash = 'storageHash' in overrides;
   const hasSchemaVersion = 'schemaVersion' in overrides;
   const hasModels = 'models' in overrides;
   const hasRelations = 'relations' in overrides;
@@ -28,7 +28,7 @@ export function createContractIR(
   const headerOpts: {
     target?: string;
     targetFamily?: string;
-    coreHash?: string;
+    storageHash?: string;
     profileHash?: string;
   } = {};
 
@@ -44,10 +44,10 @@ export function createContractIR(
     headerOpts.targetFamily = 'sql';
   }
 
-  if (hasCoreHash && overrides.coreHash !== undefined) {
-    headerOpts.coreHash = overrides.coreHash;
-  } else if (!hasCoreHash) {
-    headerOpts.coreHash = 'sha256:test';
+  if (hasStorageHash && overrides.storageHash !== undefined) {
+    headerOpts.storageHash = overrides.storageHash;
+  } else if (!hasStorageHash) {
+    headerOpts.storageHash = 'sha256:test';
   }
 
   // profileHash is not part of ContractIR, but we can accept it for header creation
@@ -59,7 +59,7 @@ export function createContractIR(
     headerOpts as {
       target: string;
       targetFamily: string;
-      coreHash: string;
+      storageHash: string;
       profileHash?: string;
     },
   );
@@ -99,7 +99,7 @@ export function createContractIR(
 
   const meta = irMeta(Object.keys(metaOpts).length > 0 ? metaOpts : undefined);
 
-  // Build result by constructing the object directly (ContractIR doesn't include coreHash/profileHash)
+  // Build result by constructing the object directly (ContractIR doesn't include storageHash/profileHash)
   // When fields are explicitly undefined, include them as undefined (tests use type assertions to bypass TS)
   const result = {
     schemaVersion:

package/dist/exports/index.js

@@ -1,6 +0,0 @@
-// src/exports/index.ts
-import { emit } from "@prisma-next/core-control-plane/emission";
-export {
-  emit
-};
-//# sourceMappingURL=index.js.map

package/dist/exports/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/exports/index.ts"],"sourcesContent":["// Re-export types from @prisma-next/contract for backward compatibility\nexport type {\n  TargetFamilyHook,\n  TypesImportSpec,\n  ValidationContext,\n} from '@prisma-next/contract/types';\nexport type { EmitOptions, EmitResult } from '@prisma-next/core-control-plane/emission';\n// Re-export emit function and types from core-control-plane\nexport { emit } from '@prisma-next/core-control-plane/emission';\n"],"mappings":";AAQA,SAAS,YAAY;","names":[]}

package/dist/src/exports/index.d.ts

@@ -1,4 +0,0 @@
-export type { TargetFamilyHook, TypesImportSpec, ValidationContext, } from '@prisma-next/contract/types';
-export type { EmitOptions, EmitResult } from '@prisma-next/core-control-plane/emission';
-export { emit } from '@prisma-next/core-control-plane/emission';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/exports/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exports/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,IAAI,EAAE,MAAM,0CAA0C,CAAC"}

package/dist/src/target-family.d.ts

@@ -1,2 +0,0 @@
-export type { TargetFamilyHook, TypesImportSpec, ValidationContext, } from '@prisma-next/contract/types';
-//# sourceMappingURL=target-family.d.ts.map

package/dist/src/target-family.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"target-family.d.ts","sourceRoot":"","sources":["../../src/target-family.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,MAAM,6BAA6B,CAAC"}

package/dist/test/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../test/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,0BAA0B,CAAC;AAE7E;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,GAAE,OAAO,CAAC,UAAU,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAChF,UAAU,CAyJZ"}