cabloy 5.1.248 → 5.1.250

package/vona/src/suite/a-training/modules/training-student/test/studentAnalysis.test.ts

@@ -0,0 +1,422 @@
+import type { TableIdentity } from 'table-identity';
+import type { ISchemaObjectExtensionField } from 'vona-module-a-openapi';
+
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { $schema } from 'vona-module-a-openapiutils';
+
+import { DtoStudentAggregateRes } from '../src/dto/studentAggregateRes.tsx';
+import { DtoStudentGroupResItem } from '../src/dto/studentGroupResItem.tsx';
+import { DtoStudentSelectReq } from '../src/dto/studentSelectReq.tsx';
+
+type StudentGroup = { level: number; count_all: string };
+type StudentAggregate = { count_all: string; count_imageId: string };
+
+async function dropStudents(ids: TableIdentity[]) {
+  const student = app.scope('training-student');
+  for (const id of ids.toReversed()) {
+    await student.model.studentContent.delete({ studentId: id }, { disableDeleted: true });
+    await student.model.student.deleteById(id, { disableDeleted: true });
+  }
+}
+
+async function readAnalysis(query: Record<string, unknown>) {
+  const groups: StudentGroup[] = await app.bean.executor.performAction(
+    'get',
+    '/training/student/group',
+    { query },
+  );
+  const aggregate: StudentAggregate = await app.bean.executor.performAction(
+    'get',
+    '/training/student/aggregate',
+    { query },
+  );
+  return {
+    groups: groups.sort((a, b) => a.level - b.level),
+    aggregate,
+  };
+}
+
+describe('studentAnalysis.test.ts', { concurrency: false }, () => {
+  it('keeps select unchanged and emits optional analysis response field supersets', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const request = $schema(DtoStudentSelectReq);
+      const requestMetadata = ZodMetadata.getOpenapiMetadata(request) as
+        | ISchemaObjectExtensionField
+        | undefined;
+      assert.equal(requestMetadata?.filter?.table, 'trainingStudent');
+      assert.equal(request.safeParse({}).success, true);
+      assert.equal(
+        request.safeParse({ name: 'Student', level: 2, createdAt: '2026-03-10~2026-03-10' })
+          .success,
+        true,
+      );
+      assert.equal(
+        request.safeParse({
+          where: { level: { _gte_: 2 } },
+          columns: ['name'],
+          orders: 'level,desc',
+          pageNo: 2,
+          pageSize: 1,
+        }).success,
+        true,
+      );
+      assert.equal(request.safeParse({ pageSize: 0 }).success, false);
+      // Filter transforms belong to runtime schema metadata; public OpenAPI strips them.
+      const createdAtSchema = ZodMetadata.getFieldSchema(request, 'createdAt');
+      assert.ok(createdAtSchema);
+      const createdAtMetadata = ZodMetadata.getOpenapiMetadata(createdAtSchema) as
+        | ISchemaObjectExtensionField
+        | undefined;
+      assert.equal(createdAtMetadata?.filter?.transform?.[0], 'a-web:dateRange');
+      for (const [DtoClass, expectedFields] of [
+        [
+          DtoStudentSelectReq,
+          ['columns', 'createdAt', 'level', 'name', 'orders', 'pageNo', 'pageSize', 'where'],
+        ],
+        [DtoStudentGroupResItem, ['count_all', 'count_imageId', 'level']],
+        [DtoStudentAggregateRes, ['count_all', 'count_imageId']],
+      ] as const) {
+        const document = await app.bean.openapi.generateJsonOfClass(DtoClass, 'V31');
+        const component = Object.values(document.components!.schemas!).find(
+          item => !('$ref' in item) && Object.hasOwn(item.properties ?? {}, expectedFields[0]),
+        );
+        assert.ok(component && !('$ref' in component));
+        assert.deepEqual(Object.keys(component.properties ?? {}).sort(), [...expectedFields]);
+        for (const field of expectedFields.filter(field => field.startsWith('count_'))) {
+          const schema = component.properties![field];
+          assert.ok(schema && !('$ref' in schema));
+          // v.optional() emits a nullable string in the V31 schema dialect.
+          assert.deepEqual(schema.type, ['string', 'null']);
+        }
+      }
+      assert.deepEqual($schema(DtoStudentGroupResItem).parse({ count_imageId: '1' }), {
+        count_imageId: '1',
+      });
+      assert.deepEqual($schema(DtoStudentGroupResItem).parse({ level: 2, count_all: '3' }), {
+        level: 2,
+        count_all: '3',
+      });
+      assert.deepEqual(
+        $schema(DtoStudentAggregateRes).parse({ count_all: '3', count_imageId: '1' }),
+        { count_all: '3', count_imageId: '1' },
+      );
+    });
+  });
+
+  it('filters real API results and refreshes warmed counts after create, update and soft delete', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const jwt = await app.bean.passport.signinMock();
+      const ids: TableIdentity[] = [];
+      const name = `Analysis-${randomUUID()}`;
+      let imageId: TableIdentity | undefined;
+      let directory: string | undefined;
+      const student = app.scope('training-student');
+      try {
+        const empty = {
+          groups: [],
+          aggregate: { count_all: '0', count_imageId: '0' },
+        };
+        assert.deepEqual(await readAnalysis({ name }), empty);
+        directory = await mkdtemp(path.join(os.tmpdir(), 'student-analysis-'));
+        const file = path.join(directory, 'student.png');
+        await writeFile(
+          file,
+          Buffer.from(
+            'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFAAH/e+m+7wAAAABJRU5ErkJggg==',
+            'base64',
+          ),
+        );
+        const image = await app.bean.image.upload(
+          'image-native:native',
+          { file, filename: 'student.png', contentType: 'image/png' },
+          { imageScene: 'training-student:studentImage' },
+        );
+        imageId = image.id;
+        for (const [index, level] of [1, 1, 2].entries()) {
+          const id = await app.bean.executor.performAction('post', '/training/student', {
+            body: {
+              name: `${name}-${index}`,
+              mobile: '13812345678',
+              level,
+              ...(index === 0 ? { imageId } : {}),
+            },
+          });
+          ids.push(id);
+          await student.model.student.updateById(id, {
+            createdAt: new Date(index === 2 ? '2026-03-11T12:00:00Z' : '2026-03-10T12:00:00Z'),
+          });
+        }
+        const initial = {
+          groups: [
+            { level: 1, count_all: '2' },
+            { level: 2, count_all: '1' },
+          ],
+          aggregate: { count_all: '3', count_imageId: '1' },
+        };
+        assert.deepEqual(await readAnalysis({ name }), initial);
+        assert.deepEqual(await readAnalysis({ name }), initial);
+        assert.deepEqual(
+          await app.bean.executor.performAction('get', '/training/student/group', {
+            query: { name, aggrs: { count: ['imageId'] } },
+          }),
+          [
+            { level: 1, count_imageId: '1' },
+            { level: 2, count_imageId: '0' },
+          ],
+        );
+        assert.deepEqual(
+          await student.service.student.group({
+            where: { name: { _startsWith_: name } },
+            groups: ['level'],
+          }),
+          initial.groups,
+        );
+        assert.deepEqual(
+          await student.service.student.aggregate({
+            where: { name: { _startsWith_: name } },
+            aggrs: { count: ['imageId'] },
+          }),
+          { count_imageId: '1' },
+        );
+        const selected = await app.bean.executor.performAction('get', '/training/student', {
+          query: { name, pageSize: 1 },
+        });
+        assert.equal(selected.total, '3');
+        assert.equal(selected.list.length, 1);
+        assert.equal(Object.hasOwn(selected.list[0], 'count_all'), false);
+        assert.deepEqual(await readAnalysis({ name, level: 2 }), {
+          groups: [{ level: 2, count_all: '1' }],
+          aggregate: { count_all: '1', count_imageId: '0' },
+        });
+        assert.deepEqual(await readAnalysis({ name, createdAt: '2026-03-10~2026-03-10' }), {
+          groups: [{ level: 1, count_all: '2' }],
+          aggregate: { count_all: '2', count_imageId: '1' },
+        });
+        assert.deepEqual(await readAnalysis({ name: `${name}-absent` }), empty);
+
+        // Dispatch concrete URLs through the HTTP router, where /:id could otherwise win.
+        for (const [action, expected] of [
+          ['group', initial.groups],
+          ['aggregate', initial.aggregate],
+        ] as const) {
+          const url = new URL(app.util.getAbsoluteUrlByApiPath(`/training/student/${action}`));
+          url.searchParams.set('name', name);
+          const response = await fetch(url, {
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${jwt.accessToken}`,
+            },
+          });
+          assert.equal(response.status, 200);
+          const body = await response.json();
+          assert.equal(body.code, 0, JSON.stringify(body));
+          const actual =
+            action === 'group'
+              ? body.data.sort((a: StudentGroup, b: StudentGroup) => a.level - b.level)
+              : body.data;
+          assert.deepEqual(actual, expected);
+        }
+        for (const [action, controls, expected] of [
+          [
+            'group',
+            { groups: ['level'], aggrs: { count: ['imageId'] } },
+            [
+              { level: 1, count_imageId: '1' },
+              { level: 2, count_imageId: '0' },
+            ],
+          ],
+          ['aggregate', { aggrs: { count: ['*'] } }, { count_all: '3' }],
+        ] as const) {
+          const url = new URL(app.util.getAbsoluteUrlByApiPath(`/training/student/${action}`));
+          url.searchParams.set('name', name);
+          for (const [key, value] of Object.entries(controls)) {
+            url.searchParams.set(key, JSON.stringify(value));
+          }
+          const response = await fetch(url, {
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${jwt.accessToken}`,
+            },
+          });
+          assert.equal(response.status, 200);
+          const body = await response.json();
+          assert.equal(body.code, 0, JSON.stringify(body));
+          assert.deepEqual(body.data, expected);
+        }
+        for (const [action, field, value] of [
+          ['group', 'groups', 'level'],
+          ['group', 'groups', '["level"'],
+          ['group', 'aggrs', '{"count":'],
+          ['aggregate', 'aggrs', '{"count":'],
+        ]) {
+          const url = new URL(app.util.getAbsoluteUrlByApiPath(`/training/student/${action}`));
+          url.searchParams.set('name', name);
+          url.searchParams.set(field, value);
+          const response = await fetch(url, {
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${jwt.accessToken}`,
+            },
+          });
+          assert.equal(response.status, 422);
+          assert.equal((await response.json()).code, 422);
+        }
+        for (const [action, controls] of [
+          ['', { groups: ['level'] }],
+          ['', { aggrs: { count: ['*'] } }],
+          ['group', { groups: [] }],
+          ['group', { groups: ['level', 'level'] }],
+          ['group', { groups: ['name'] }],
+          ['group', { aggrs: {} }],
+          ['group', { aggrs: { count: [] } }],
+          ['group', { aggrs: { count: ['*', '*'] } }],
+          ['group', { aggrs: { count: ['mobile'] } }],
+          ['group', { aggrs: { sum: ['level'] } }],
+          ['aggregate', { groups: ['level'] }],
+          ['aggregate', { groups: [] }],
+        ] as const) {
+          await assert.rejects(
+            () =>
+              app.bean.executor.performAction(
+                'get',
+                action === '' ? '/training/student' : `/training/student/${action}`,
+                {
+                  query: { name, ...controls },
+                },
+              ),
+            (error: { code?: number }) => error.code === 422,
+          );
+        }
+        await assert.rejects(
+          () => student.service.student.group({ groups: ['name'] } as never),
+          (error: { code?: number }) => error.code === 422,
+        );
+        await assert.rejects(
+          () => student.service.student.aggregate({ groups: ['level'] } as never),
+          (error: { code?: number }) => error.code === 422,
+        );
+        assert.deepEqual(
+          await readAnalysis({
+            name,
+            columns: ['name'],
+            orders: 'level,desc',
+            pageNo: 2,
+            pageSize: 1,
+          }),
+          initial,
+        );
+        // Raw predicates are shared with select and take precedence over named filters.
+        assert.deepEqual(
+          await readAnalysis({
+            name,
+            level: 1,
+            where: { level: 2 },
+          }),
+          {
+            groups: [{ level: 2, count_all: '1' }],
+            aggregate: { count_all: '1', count_imageId: '0' },
+          },
+        );
+        for (const action of ['group', 'aggregate'] as const) {
+          for (const query of [
+            { name, pageSize: 0 },
+            { name, pageNo: 0 },
+          ]) {
+            await assert.rejects(
+              () =>
+                app.bean.executor.performAction('get', `/training/student/${action}`, { query }),
+              (error: { code?: number }) => error.code === 422,
+            );
+          }
+        }
+        await app.bean.executor.performAction('patch', '/training/student/:id', {
+          params: { id: ids[1] },
+          body: { name: `${name}-1`, mobile: '13812345678', level: 2 },
+        });
+        assert.deepEqual(await readAnalysis({ name }), {
+          groups: [
+            { level: 1, count_all: '1' },
+            { level: 2, count_all: '2' },
+          ],
+          aggregate: { count_all: '3', count_imageId: '1' },
+        });
+        await app.bean.executor.performAction('delete', '/training/student/:id', {
+          params: { id: ids[0] },
+        });
+        assert.equal(
+          (await student.model.student.getById(ids[0], { disableDeleted: true }))?.deleted,
+          true,
+        );
+        assert.deepEqual(await readAnalysis({ name }), {
+          groups: [{ level: 2, count_all: '2' }],
+          aggregate: { count_all: '2', count_imageId: '0' },
+        });
+      } finally {
+        try {
+          await dropStudents(ids);
+          if (imageId !== undefined) await app.bean.image.delete(imageId);
+        } finally {
+          if (directory) await rm(directory, { recursive: true, force: true });
+          await app.bean.passport.signout();
+        }
+      }
+    });
+  });
+
+  it('excludes students owned by another instance', async () => {
+    // Keep the full UUID within the VARCHAR(50) name column.
+    const name = `Analysis-${randomUUID()}`;
+    const ids: TableIdentity[] = [];
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          ids.push(
+            await app.bean.executor.performAction('post', '/training/student', {
+              body: { name, mobile: '13812345678', level: 3 },
+            }),
+          );
+          assert.deepEqual(await readAnalysis({ name }), {
+            groups: [{ level: 3, count_all: '1' }],
+            aggregate: { count_all: '1', count_imageId: '0' },
+          });
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+      await app.bean.executor.mockCtx(
+        async () => {
+          await app.bean.passport.signinMock();
+          try {
+            assert.deepEqual(await readAnalysis({ name }), {
+              groups: [],
+              aggregate: { count_all: '0', count_imageId: '0' },
+            });
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+      await app.bean.executor.mockCtx(async () => {
+        assert.deepEqual(
+          await app.scope('training-student').service.student.aggregate({
+            where: { name },
+          }),
+          { count_all: '1', count_imageId: '0' },
+        );
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStudents(ids);
+      });
+    }
+  });
+});

package/vona/src/suite-vendor/a-cabloy/modules/a-rbac/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-rbac",
-  "version": "5.0.19",
+  "version": "5.0.20",
   "description": "",
   "keywords": [
     "Vona Module"

package/vona/src/suite-vendor/a-cabloy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-cabloy",
-  "version": "5.1.71",
+  "version": "5.1.72",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",
@@ -10,7 +10,7 @@
     "vona-module-a-cabloy": "workspace:^",
     "vona-module-a-layoutprofile": "^5.0.2",
     "vona-module-a-markdown": "^5.0.3",
-    "vona-module-a-rbac": "^5.0.19",
+    "vona-module-a-rbac": "^5.0.20",
     "vona-module-a-socket": "workspace:^",
     "vona-module-a-ssr": "workspace:^",
     "vona-module-a-ssrhmr": "workspace:^"

package/vona/src/suite-vendor/a-captcha/modules/a-captcha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-captcha",
-  "version": "5.1.16",
+  "version": "5.1.17",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-captcha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-captcha",
-  "version": "5.1.20",
+  "version": "5.1.21",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/vona/src/suite-vendor/a-vona/modules/a-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-core",
-  "version": "5.1.70",
+  "version": "5.1.71",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-hmr/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-hmr",
-  "version": "5.1.16",
+  "version": "5.1.17",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-locale/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-locale",
-  "version": "5.1.13",
+  "version": "5.1.14",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-openapi",
-  "version": "5.1.27",
+  "version": "5.1.28",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-openapiutils",
-  "version": "5.1.24",
+  "version": "5.1.25",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/src/lib/utils.ts

@@ -38,7 +38,7 @@ export function getTargetDecoratorDtoOpenapi(
       replace: true,
     });
   }
-  return appMetadata.getOwnMetadata(SymbolDecoratorDtoOpenapi, target);
+  return appMetadata.getMetadata(SymbolDecoratorDtoOpenapi, target);
 }
 
 export function setTargetDecoratorDtoOpenapi(

package/vona/src/suite-vendor/a-vona/modules/a-orm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-orm",
-  "version": "5.1.39",
+  "version": "5.1.40",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "db",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-orm/src/.metadata/index.ts

@@ -1,4 +1,30 @@
 // eslint-disable
+/** schedule: begin */
+export * from '../bean/schedule.softDeletionPrune.ts';
+
+import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
+declare module 'vona-module-a-schedule' {
+
+    export interface IScheduleRecord {
+      'a-orm:softDeletionPrune': IDecoratorScheduleOptions;
+    }
+
+
+}
+declare module 'vona-module-a-orm' {
+
+        export interface ScheduleSoftDeletionPrune {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface ScheduleSoftDeletionPrune {
+            get $beanFullName(): 'a-orm.schedule.softDeletionPrune';
+            get $onionName(): 'a-orm:softDeletionPrune';
+            get $onionOptions(): IDecoratorScheduleOptions;
+          }
+}
+/** schedule: end */
 /** aopMethod: begin */
 export * from '../bean/aopMethod.transaction.ts';
 import type { IAopMethodOptionsTransaction } from '../bean/aopMethod.transaction.ts';
@@ -261,32 +287,6 @@ export interface IModuleQueue {
   'doubleDelete': QueueDoubleDelete;
 }
 /** queue: end */
-/** schedule: begin */
-export * from '../bean/schedule.softDeletionPrune.ts';
-
-import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
-declare module 'vona-module-a-schedule' {
-
-    export interface IScheduleRecord {
-      'a-orm:softDeletionPrune': IDecoratorScheduleOptions;
-    }
-
-
-}
-declare module 'vona-module-a-orm' {
-
-        export interface ScheduleSoftDeletionPrune {
-          /** @internal */
-          get scope(): ScopeModuleAOrm;
-        }
-
-          export interface ScheduleSoftDeletionPrune {
-            get $beanFullName(): 'a-orm.schedule.softDeletionPrune';
-            get $onionName(): 'a-orm:softDeletionPrune';
-            get $onionOptions(): IDecoratorScheduleOptions;
-          }
-}
-/** schedule: end */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';

package/vona/src/suite-vendor/a-vona/modules/a-orm/src/lib/aggregateResult.ts

@@ -0,0 +1,53 @@
+type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+type AggregateSpec = Partial<Record<AggregateFunction, PropertyKey | readonly PropertyKey[]>>;
+
+export function normalizeAggregateValue(value: unknown, fn: 'count'): string | undefined;
+export function normalizeAggregateValue(
+  value: unknown,
+  fn: AggregateFunction,
+): string | null | undefined;
+export function normalizeAggregateValue(
+  value: unknown,
+  fn: AggregateFunction,
+): string | null | undefined {
+  if (value === undefined) return value;
+  if (value === null && fn !== 'count') return value;
+  if (typeof value === 'string') {
+    if (fn !== 'count' || /^(0|[1-9]\d*)$/.test(value)) return value;
+  } else if (typeof value === 'number') {
+    if (Number.isFinite(value) && (fn !== 'count' || (Number.isSafeInteger(value) && value >= 0))) {
+      return String(value);
+    }
+  } else if (typeof value === 'bigint' && (fn !== 'count' || value >= 0n)) {
+    return String(value);
+  }
+  throw new TypeError(`Invalid ORM ${fn} aggregate result`);
+}
+
+export function normalizeAggregateRows<T extends {}>(rows: T[], aggrs?: AggregateSpec): T[] {
+  if (!aggrs || rows.length === 0) return rows;
+  const aliases: [string, AggregateFunction][] = [];
+  for (const fn of ['count', 'sum', 'avg', 'min', 'max'] as const) {
+    const columns = aggrs[fn];
+    if (columns === undefined) continue;
+    for (const column of typeof columns === 'object' ? columns : [columns]) {
+      aliases.push([`${fn}_${column === '*' ? 'all' : String(column)}`, fn]);
+    }
+  }
+  let result = rows;
+  for (const [index, row] of rows.entries()) {
+    let target = row;
+    for (const [alias, fn] of aliases) {
+      if (!Object.hasOwn(row, alias)) continue;
+      const value = (row as Record<string, unknown>)[alias];
+      const normalized = normalizeAggregateValue(value, fn);
+      if (value === normalized) continue;
+      if (target === row) target = { ...row };
+      (target as Record<string, unknown>)[alias] = normalized;
+    }
+    if (target === row) continue;
+    if (result === rows) result = [...rows];
+    result[index] = target;
+  }
+  return result;
+}