@prisma-next/adapter-postgres 0.16.0-dev.3 → 0.16.0-dev.31

package/src/core/sql-renderer.ts

@@ -5,18 +5,23 @@ import {
   type AggregateExpr,
   type AnyExpression,
   type AnyFromSource,
+  type AnyJsonValueProjection,
   type AnyParamRef,
   type AnyQueryAst,
   type BinaryExpr,
+  type CaseExpr,
+  type CastExpr,
   type ColumnRef,
   collectOrderedParamRefs,
   type DeleteAst,
+  type FunctionCallExpr,
   type InsertAst,
   type InsertValue,
   type JoinAst,
   type JoinOnExpr,
   type JsonArrayAggExpr,
   type JsonObjectExpr,
+  type JsonValueProjectionVisitor,
   type ListExpression,
   LiteralExpr,
   type LoweredParam,
@@ -32,8 +37,15 @@ import {
   type UpdateAst,
   type WindowFuncExpr,
 } from '@prisma-next/sql-relational-core/ast';
-import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
+import { isPgEnumParams } from '@prisma-next/target-postgres/codecs';
+import {
+  escapeLiteral,
+  quoteIdentifier,
+  quoteQualifiedName,
+} from '@prisma-next/target-postgres/sql-utils';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { assertNever, InternalError } from '@prisma-next/utils/internal-error';
+import { adapterError } from './adapter-errors';
 import type { PostgresContract } from './types';
 
 /**
@@ -85,13 +97,15 @@ function renderTypedParam(
     meta !== undefined ||
     codecLookup.targetTypesFor(codecId) !== undefined;
   if (!isRegistered) {
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.PARAM_REF_MISSING_CODEC',
       `Postgres lowering: ParamRef carries codecId "${codecId}" but the ` +
         'assembled codec lookup has no entry for it. This usually indicates ' +
         'a missing extension pack in the runtime stack — register the pack ' +
-        'that contributes this codec (e.g. `extensionPacks: [pgvectorRuntime]`), ' +
+        'that contributes this codec (e.g. `extensions: [pgvectorRuntime]`), ' +
         'or use the codec directly from `@prisma-next/target-postgres/codecs` ' +
         "if it's a builtin.",
+      { meta: { codecId } },
     );
   }
   // `typeParams` above already resolved a parameterized codec's per-instance
@@ -107,6 +121,15 @@ function renderTypedParam(
   const nativeType = isRecord(dialectBlock) ? dialectBlock['nativeType'] : undefined;
   if (typeof nativeType === 'string') {
     const arraySuffix = many ? '[]' : '';
+    // A `typeParams.typeName` marks a named database type (e.g. a native
+    // enum): cast to its quoted, schema-qualified identifier so Postgres does
+    // not case-fold it (`$1::HoldType` would resolve as `holdtype`). Mirrors
+    // the DDL-side policy in `buildColumnTypeSql`. Builtin spellings
+    // (`double precision`, `jsonb`, …) stay verbatim — quoting them would
+    // turn them into (nonexistent) user-type lookups.
+    if (isPgEnumParams(typeParams)) {
+      return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
+    }
     if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {
       return `$${index}::${nativeType}${arraySuffix}`;
     }
@@ -121,6 +144,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
 
+function unreachableKind(value: never): string {
+  const candidate: unknown = value;
+  if (
+    typeof candidate === 'object' &&
+    candidate !== null &&
+    'kind' in candidate &&
+    typeof candidate.kind === 'string'
+  ) {
+    return candidate.kind;
+  }
+  return 'unknown';
+}
+
 /**
  * Per-render carrier threaded through every helper. Bundles the param-index map (for `$N` numbering) and the assembled-stack `codecLookup` (for cast policy at the `renderTypedParam` chokepoint). Carrying both on a single value keeps helper signatures stable.
  */
@@ -169,9 +205,7 @@ export function renderLoweredSql(
       break;
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported AST node kind: ${(node satisfies never as { kind: string }).kind}`,
-      );
+      assertNever(node, `Unsupported AST node kind: ${unreachableKind(node)}`);
   }
 
   return Object.freeze({ sql, params: Object.freeze(params) });
@@ -430,14 +464,18 @@ function qualifyTableFromNamespaceCoordinate(
   }
   const namespace = contract.storage.namespaces[table.namespaceId];
   if (namespace === undefined) {
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.NAMESPACE_UNKNOWN',
       `Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`,
+      { meta: { table: table.name, namespaceId: table.namespaceId, reason: 'not-present' } },
     );
   }
   const qualifyTable = namespace.qualifyTable;
   if (qualifyTable === undefined) {
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.NAMESPACE_UNKNOWN',
       `Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised as a Postgres schema on the contract`,
+      { meta: { table: table.name, namespaceId: table.namespaceId, reason: 'not-materialised' } },
     );
   }
   return qualifyTable.call(namespace, table.name);
@@ -465,19 +503,27 @@ function renderSource(
     case 'function-source': {
       const args = node.args.map((arg) => renderExpr(arg, contract, pim)).join(', ');
       const call = `${node.fn}(${args})`;
-      return node.alias !== undefined ? `${call} AS ${quoteIdentifier(node.alias)}` : call;
+      const ordinality = node.ordinality ? ' WITH ORDINALITY' : '';
+      const alias = node.alias === undefined ? '' : ` AS ${quoteIdentifier(node.alias)}`;
+      const columnAliases =
+        node.columnAliases === undefined
+          ? ''
+          : `(${node.columnAliases.map((column) => quoteIdentifier(column)).join(', ')})`;
+      return `${call}${ordinality}${alias}${columnAliases}`;
     }
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported source node kind: ${(node satisfies never as { kind: string }).kind}`,
-      );
+      assertNever(node, `Unsupported source node kind: ${unreachableKind(node)}`);
   }
 }
 
 function assertScalarSubquery(query: SelectAst): void {
   if (query.projection.length !== 1) {
-    throw new Error('Subquery expressions must project exactly one column');
+    throw adapterError(
+      'RUNTIME.AST_INVALID',
+      'Subquery expressions must project exactly one column',
+      { meta: { node: 'subquery-expr' } },
+    );
   }
 }
 
@@ -518,6 +564,9 @@ function isAtomicExpressionKind(kind: AnyExpression['kind']): boolean {
     case 'literal':
     case 'aggregate':
     case 'window-func':
+    case 'function-call':
+    case 'cast':
+    case 'case':
     case 'json-object':
     case 'json-array-agg':
     case 'list':
@@ -644,6 +693,44 @@ function renderWindowFuncExpr(
   return `${fn}(${args}) OVER (${over})`;
 }
 
+function renderFunctionCallExpr(
+  expr: FunctionCallExpr,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
+  const args = expr.args.map((arg) => renderExpr(arg, contract, pim)).join(', ');
+  return `${expr.fn}(${args})`;
+}
+
+function renderCastExpr(expr: CastExpr, contract: PostgresContract, pim: ParamIndexMap): string {
+  return `CAST(${renderExpr(expr.expr, contract, pim)} AS ${expr.targetType})`;
+}
+
+function renderCaseExpr(expr: CaseExpr, contract: PostgresContract, pim: ParamIndexMap): string {
+  const branches = expr.branches
+    .map(
+      (branch) =>
+        `WHEN ${renderExpr(branch.condition, contract, pim)} THEN ${renderExpr(branch.value, contract, pim)}`,
+    )
+    .join(' ');
+  const elseClause =
+    expr.elseExpr === undefined ? '' : ` ELSE ${renderExpr(expr.elseExpr, contract, pim)}`;
+  return `CASE ${branches}${elseClause} END`;
+}
+
+function renderJsonValueProjection(
+  projection: AnyJsonValueProjection,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
+  const visitor: JsonValueProjectionVisitor<string> = {
+    codec: ({ value }) => renderExpr(value, contract, pim),
+    native: ({ value }) => renderExpr(value, contract, pim),
+    document: ({ value }) => renderExpr(value, contract, pim),
+  };
+  return projection.accept(visitor);
+}
+
 function renderJsonObjectExpr(
   expr: JsonObjectExpr,
   contract: PostgresContract,
@@ -652,10 +739,7 @@ function renderJsonObjectExpr(
   const args = expr.entries
     .flatMap((entry): [string, string] => {
       const key = `'${escapeLiteral(entry.key)}'`;
-      if (entry.value.kind === 'literal') {
-        return [key, renderLiteral(entry.value)];
-      }
-      return [key, renderExpr(entry.value, contract, pim)];
+      return [key, renderJsonValueProjection(entry.value, contract, pim)];
     })
     .join(', ');
   return `json_build_object(${args})`;
@@ -680,7 +764,7 @@ function renderJsonArrayAggExpr(
     expr.orderBy && expr.orderBy.length > 0
       ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}`
       : '';
-  const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;
+  const aggregated = `json_agg(${renderJsonValueProjection(expr.expr, contract, pim)}${aggregateOrderBy})`;
   if (expr.onEmpty === 'emptyArray') {
     return `coalesce(${aggregated}, json_build_array())`;
   }
@@ -702,6 +786,12 @@ function renderExpr(expr: AnyExpression, contract: PostgresContract, pim: ParamI
       return renderAggregateExpr(node, contract, pim);
     case 'window-func':
       return renderWindowFuncExpr(node, contract, pim);
+    case 'function-call':
+      return renderFunctionCallExpr(node, contract, pim);
+    case 'cast':
+      return renderCastExpr(node, contract, pim);
+    case 'case':
+      return renderCaseExpr(node, contract, pim);
     case 'json-object':
       return renderJsonObjectExpr(node, contract, pim);
     case 'json-array-agg':
@@ -738,16 +828,14 @@ function renderExpr(expr: AnyExpression, contract: PostgresContract, pim: ParamI
       return renderRawExpr(node, contract, pim);
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported expression node kind: ${(node satisfies never as { kind: string }).kind}`,
-      );
+      assertNever(node, `Unsupported expression node kind: ${unreachableKind(node)}`);
   }
 }
 
 function renderParamRef(ref: AnyParamRef, pim: ParamIndexMap): string {
   const index = pim.indexMap.get(ref);
   if (index === undefined) {
-    throw new Error('ParamRef not found in index map');
+    throw new InternalError('ParamRef not found in index map');
   }
   if (ref.kind === 'prepared-param-ref') {
     return renderTypedParam(
@@ -824,8 +912,10 @@ function renderOperation(
       }
       const arg = args[Number(argIndex)];
       if (arg === undefined) {
-        throw new Error(
+        throw adapterError(
+          'CONTRACT.PACK_CONTRIBUTION_INVALID',
           `Operation lowering template for "${expr.method}" referenced missing argument {{arg${argIndex}}}; template has ${args.length} arg(s)`,
+          { meta: { method: expr.method } },
         );
       }
       return arg;
@@ -888,7 +978,11 @@ function getInsertColumnOrder(
     }
   }
   if (!table) {
-    throw new Error(`INSERT target table not found in contract storage: ${tableName}`);
+    throw adapterError(
+      'RUNTIME.AST_INVALID',
+      `INSERT target table not found in contract storage: ${tableName}`,
+      { meta: { node: 'insert', table: tableName } },
+    );
   }
   return Object.keys(table.columns);
 }
@@ -912,9 +1006,7 @@ function renderInsertValue(
       return renderExpr(value, contract, pim);
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported value node in INSERT: ${(value satisfies never as { kind: string }).kind}`,
-      );
+      assertNever(value, `Unsupported value node in INSERT: ${unreachableKind(value)}`);
   }
 }
 
@@ -922,7 +1014,9 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
   const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
   const rows = ast.rows;
   if (rows.length === 0) {
-    throw new Error('INSERT requires at least one row');
+    throw adapterError('RUNTIME.AST_INVALID', 'INSERT requires at least one row', {
+      meta: { node: 'insert' },
+    });
   }
   const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);
   const insertClause = (() => {
@@ -960,7 +1054,11 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
     ? (() => {
         const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
         if (conflictColumns.length === 0) {
-          throw new Error('INSERT onConflict requires at least one conflict column');
+          throw adapterError(
+            'RUNTIME.AST_INVALID',
+            'INSERT onConflict requires at least one conflict column',
+            { meta: { node: 'insert-on-conflict' } },
+          );
         }
 
         const action = ast.onConflict.action;
@@ -970,7 +1068,11 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
           case 'do-update-set': {
             const updateEntries = Object.entries(action.set);
             if (updateEntries.length === 0) {
-              throw new Error('INSERT onConflict do-update-set requires at least one assignment');
+              throw adapterError(
+                'RUNTIME.AST_INVALID',
+                'INSERT onConflict do-update-set requires at least one assignment',
+                { meta: { node: 'insert-on-conflict' } },
+              );
             }
             const updates = updateEntries.map(([colName, value]) => {
               return `${quoteIdentifier(colName)} = ${renderExpr(value, contract, pim)}`;
@@ -979,9 +1081,7 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
           }
           // v8 ignore next 4
           default:
-            throw new Error(
-              `Unsupported onConflict action: ${(action satisfies never as { kind: string }).kind}`,
-            );
+            assertNever(action, `Unsupported onConflict action: ${unreachableKind(action)}`);
         }
       })()
     : '';
@@ -996,7 +1096,9 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract, pim: ParamInde
   const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
   const setEntries = Object.entries(ast.set);
   if (setEntries.length === 0) {
-    throw new Error('UPDATE requires at least one SET assignment');
+    throw adapterError('RUNTIME.AST_INVALID', 'UPDATE requires at least one SET assignment', {
+      meta: { node: 'update' },
+    });
   }
   const setClauses = setEntries.map(([col, val]) => {
     const column = quoteIdentifier(col);

package/src/exports/control.ts

@@ -4,19 +4,18 @@ import {
   escapeLiteral,
   qualifyName,
   quoteIdentifier,
-  SqlEscapeError,
 } from '@prisma-next/target-postgres/sql-utils';
 import { PostgresControlAdapter } from '../core/control-adapter';
 import {
   createPostgresDefaultFunctionRegistry,
   createPostgresMutationDefaultGeneratorDescriptors,
-  createPostgresScalarTypeDescriptors,
+  postgresAuthoringTypes,
 } from '../core/control-mutation-defaults';
 import { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';
 
 const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'> = {
   ...postgresAdapterDescriptorMeta,
-  scalarTypeDescriptors: createPostgresScalarTypeDescriptors(),
+  authoring: { type: postgresAuthoringTypes, valueObjectStorageType: 'Jsonb' },
   controlMutationDefaults: {
     defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
     generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors(),
@@ -32,4 +31,4 @@ export { parsePostgresDefault } from '@prisma-next/target-postgres/default-norma
 export { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
 export { createPostgresBuiltinCodecLookup } from '../core/codec-lookup';
 export { PostgresControlAdapter } from '../core/control-adapter';
-export { escapeLiteral, qualifyName, quoteIdentifier, SqlEscapeError };
+export { escapeLiteral, qualifyName, quoteIdentifier };

package/src/exports/runtime.ts

@@ -39,7 +39,7 @@ const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres',
     create(stack): SqlRuntimeAdapter {
       // The runtime `ExecutionStack` does not (yet) carry a pre-assembled `codecLookup` field the way the control `ControlStack` does, so we derive an equivalent lookup here from the stack's component metadata (target + adapter + extension packs) using the same assembly helper that `createControlStack` uses. This keeps the renderer fed with the same codec set on both planes — including extension-contributed codecs like
       // `pg/vector@1` from `@prisma-next/extension-pgvector`.
-      const components = [stack.target, stack.adapter, ...stack.extensionPacks];
+      const components = [stack.target, stack.adapter, ...stack.extensions];
       const codecLookup = extractCodecLookup(components);
       return createPostgresAdapter({ codecLookup });
     },

package/dist/adapter-BaZsfXGA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-BaZsfXGA.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecRegistry } from '@prisma-next/framework-components/codec';\nimport { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type {\n  Adapter,\n  AdapterProfile,\n  AnyQueryAst,\n  LowererContext,\n  RawSqlLiteral,\n  SqlQueryable,\n} from '@prisma-next/sql-relational-core/ast';\nimport { isDdlNode } from '@prisma-next/sql-relational-core/ast';\nimport type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n    distinctOn: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n    lateral: true,\n    scalarList: true,\n  },\n});\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecLookup: CodecRegistry;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    const controlAdapter = new PostgresControlAdapter(this.codecLookup);\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) =>\n        controlAdapter.readMarkerDiscriminated(\n          {\n            familyId: 'sql',\n            targetId: 'postgres',\n            query: async <Row = Record<string, unknown>>(\n              sql: string,\n              params?: readonly unknown[],\n            ) => {\n              const result = await queryable.query<Row>(sql, params);\n              return { rows: [...result.rows] };\n            },\n            close: async () => {},\n          },\n          APP_SPACE_ID,\n        ),\n    });\n  }\n\n  lower(\n    ast: AnyQueryAst | PostgresDdlNode,\n    context: LowererContext<PostgresContract>,\n  ): PostgresLoweredStatement {\n    if (isDdlNode(ast)) {\n      throw new Error(\n        'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',\n      );\n    }\n    return renderLoweredSql(ast, context.contract, this.codecLookup);\n  }\n}\n\n/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */\nexport const postgresRawCodecInferer: RawCodecInferer = {\n  inferCodec(value: RawSqlLiteral): string {\n    switch (typeof value) {\n      case 'number':\n        return Number.isSafeInteger(value) && value % 1 === 0 ? 'pg/int4' : 'pg/float8';\n      case 'bigint':\n        return 'pg/int8';\n      case 'string':\n        return 'pg/text';\n      case 'boolean':\n        return 'pg/bool';\n      case 'object':\n        if (value instanceof Uint8Array) return 'pg/bytea';\n    }\n    throw new Error(\n      'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n    );\n  },\n};\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;AAkBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACX,YAAY;CACd;CACA,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EACjB,SAAS;EACT,YAAY;CACd;AACF,CAAC;AAED,IAAM,sBAAN,MAEA;CAEE,WAAoB;CACpB,WAAoB;CAEpB;CACA;CAEA,YAAY,SAAkC;EAC5C,KAAK,cAAc,SAAS,eAAe,iCAAiC;EAC5E,MAAM,iBAAiB,IAAI,uBAAuB,KAAK,WAAW;EAClE,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,aAAa,cACX,eAAe,wBACb;IACE,UAAU;IACV,UAAU;IACV,OAAO,OACL,KACA,WACG;KAEH,OAAO,EAAE,MAAM,CAAC,IAAG,MADE,UAAU,MAAW,KAAK,MAAM,EAAA,CAC3B,IAAI,EAAE;IAClC;IACA,OAAO,YAAY,CAAC;GACtB,GACA,YACF;EACJ,CAAC;CACH;CAEA,MACE,KACA,SAC0B;EAC1B,IAAI,UAAU,GAAG,GACf,MAAM,IAAI,MACR,6HACF;EAEF,OAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,WAAW;CACjE;AACF;;AAGA,MAAa,0BAA2C,EACtD,WAAW,OAA8B;CACvC,QAAQ,OAAO,OAAf;EACE,KAAK,UACH,OAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,MAAM,IAAI,YAAY;EACtE,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,IAAI,iBAAiB,YAAY,OAAO;CAC5C;CACA,MAAM,IAAI,MACR,6GACF;AACF,EACF;AAEA,SAAgB,sBAAsB,SAAkC;CACtE,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}