@nest-yalc-2/omnikernel-module 2.2.2 → 2.2.6

package/src/__tests__/omni-extension-projection.service.spec.ts

@@ -1,806 +1,806 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  jest,
-} from "@jest/globals";
-import {
-  BadRequestException,
-  ConflictException,
-  NotFoundException,
-} from "@nestjs/common";
-import {
-  applyProjectionIndexesForBootstrap,
-  createProjectionDialect,
-  type ProjectionDialect,
-} from "@nest-yalc-2/crud-gen";
-import { randomUUID } from 'node:crypto';
-import { rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { DataSource } from "typeorm";
-
-import { OmniNamedEntity } from '../base/omni-named.entity.js';
-import { OmniRecordEntity } from '../base/omni-record.entity.js';
-import { OmniRelationEntity } from '../base/omni-relation.entity.js';
-import { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
-import { OmniExtensionProjectionService } from '../omni-extension-projection.service.js';
-import {
-  createOmniExtensionProjectionEntity,
-  defineOmniExtensionProjection,
-} from '../omni-extension-projection.definition.js';
-import { OmniExternalRefBindingValidator } from '../omni-external-ref-binding.validator.js';
-import { OmniExternalRefService } from '../omni-external-ref.service.js';
-import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
-import { defineOmniRelationProjection } from '../omni-relation-projection.definition.js';
-import { OmniRelationProjectionService } from '../omni-relation-projection.service.js';
-import { createOmniRelationKindContract } from '../omni-relation-kind.contract.js';
-import { createOmniProjectionReaderCatalog } from '../omni-projection.catalog.js';
-import { OmniRecordStatus } from '../omni-record-status.enum.js';
-
-type ExtensionRow = {
-  scopeId: string;
-  guid: string;
-  label: string;
-  payload: Record<string, unknown>;
-  revision?: number;
-  priority?: number | null;
-};
-
-const definition = defineOmniExtensionProjection({
-  id: "example.extension-projection.v1",
-  tableName: "example-extension-projection",
-  identity: { column: "guid", uniqueWithinScope: true },
-  scope: { column: "scopeId", serverOwned: true },
-  revision: { column: "revision" },
-  payload: { column: "payload", allowCreate: true },
-  deletion: "hard",
-  fields: [
-    {
-      name: "guid",
-      storage: "column",
-      column: "guid",
-      codec: "uuid",
-      nullable: false,
-      requiredOnCreate: true,
-    },
-    {
-      name: "label",
-      storage: "column",
-      column: "label",
-      codec: "string",
-      nullable: false,
-      requiredOnCreate: true,
-      query: { filter: ["eq"], sort: true },
-    },
-    {
-      name: "priority",
-      storage: "json",
-      path: ["attributes", "priority"],
-      codec: "integer",
-      nullable: true,
-      query: { filter: ["eq", "range"], sort: true },
-      index: { name: "example_extension_projection_priority_idx" },
-    },
-    {
-      name: "enabled",
-      storage: "json",
-      path: ["attributes", "enabled"],
-      codec: "boolean",
-      nullable: false,
-      requiredOnCreate: true,
-      query: { filter: ["eq"], sort: true },
-      index: { name: "example_extension_projection_enabled_idx" },
-    },
-  ],
-  owner: {
-    kind: "example_extension",
-    title: "Example extension",
-    status: OmniRecordStatus.Active,
-    schema: { id: "example.extension.v1", version: 1 },
-  },
-});
-
-const relationDefinition = defineOmniRelationProjection({
-  id: "example.extension-link.v1",
-  relation: {
-    kind: "links",
-    sourceKind: definition.owner.kind,
-    targetKind: definition.owner.kind,
-    schema: { id: "example.extension-link.v1", version: 1 },
-  },
-});
-
-const alphaScope = {
-  scopeId: "scope-alpha",
-  cacheKey: (key: string) => `scope-alpha:${key}`,
-};
-const bravoScope = {
-  scopeId: "scope-bravo",
-  cacheKey: (key: string) => `scope-bravo:${key}`,
-};
-
-const firstGuid = "10000000-0000-4000-8000-000000000001";
-const secondGuid = "10000000-0000-4000-8000-000000000002";
-const thirdGuid = "10000000-0000-4000-8000-000000000003";
-const bravoOnlyGuid = "10000000-0000-4000-8000-000000000004";
-
-const events = {
-  errorBadRequest: (_event: string, options: any) =>
-    new BadRequestException(options.response.message),
-  errorConflict: (_event: string, options: any) =>
-    new ConflictException(options.response.message),
-  errorNotFound: (_event: string, options: any) =>
-    new NotFoundException(options.response.message),
-};
-
-const postgresUrl = process.env.OMNI_EXTENSION_PROJECTION_POSTGRES_URL;
-const dialectCases: Array<{
-  name: "sqlite" | "postgres";
-  url?: string;
-}> = [
-  { name: "sqlite" },
-  ...(postgresUrl ? [{ name: "postgres" as const, url: postgresUrl }] : []),
-];
-
-describe.each(dialectCases)(
-  "Omni extension projection (%s)",
-  ({ name, url }) => {
-    let dataSource: DataSource;
-    let dialect: ProjectionDialect;
-    let extensionEntity: any;
-    let service: InstanceType<
-      typeof OmniExtensionProjectionService<ExtensionRow>
-    >;
-    let bravoService: InstanceType<
-      typeof OmniExtensionProjectionService<ExtensionRow>
-    >;
-
-    beforeEach(async () => {
-      dialect = createProjectionDialect(name);
-      extensionEntity = createOmniExtensionProjectionEntity<ExtensionRow>(
-        definition,
-        dialect,
-      );
-      dataSource = new DataSource({
-        type: name,
-        ...(name === "sqlite"
-          ? { database: ":memory:" }
-          : { url: url!, ssl: false }),
-        dropSchema: true,
-        synchronize: true,
-        entities: [
-          OmniNamedEntity,
-          OmniRecordEntity,
-          OmniRelationEntity,
-          OmniExternalRefEntity,
-          extensionEntity,
-        ],
-      });
-      await dataSource.initialize();
-      await applyProjectionIndexesForBootstrap(dataSource, dialect, definition);
-      const extensions = dataSource.getRepository<ExtensionRow>(extensionEntity);
-      const owners = dataSource.getRepository(OmniRecordEntity);
-      service = new OmniExtensionProjectionService(
-        extensions,
-        owners,
-        dataSource,
-        alphaScope,
-        dialect,
-        events as never,
-        definition,
-      );
-      bravoService = new OmniExtensionProjectionService(
-        extensions,
-        owners,
-        dataSource,
-        bravoScope,
-        dialect,
-        events as never,
-        definition,
-      );
-    });
-
-    afterEach(async () => {
-      if (dataSource.isInitialized) await dataSource.destroy();
-    });
-
-    it("creates, reads, filters, sorts, patches, and isolates owner identity by scope and kind", async () => {
-      const first = await service.createEntity({
-        guid: firstGuid,
-        label: "first",
-        priority: 2,
-        enabled: true,
-        payload: { retained: true },
-      });
-      await service.createEntity({
-        guid: secondGuid,
-        label: "second",
-        priority: 1,
-        enabled: false,
-      });
-      await bravoService.createEntity({
-        guid: firstGuid,
-        label: "bravo copy",
-        priority: 8,
-        enabled: true,
-      });
-
-      expect(first).toMatchObject({
-        guid: firstGuid,
-        label: "first",
-        priority: 2,
-        revision: 1,
-        payload: { retained: true, attributes: { priority: 2, enabled: true } },
-      });
-      expect(await bravoService.getEntity({ guid: firstGuid })).toMatchObject({
-        label: "bravo copy",
-        priority: 8,
-        enabled: true,
-        revision: 1,
-      });
-      const [grid, count] = (await service.getEntityListExtended(
-        {
-          where: { filters: { priority: 2, enabled: true } },
-          order: { label: "DESC" },
-        } as never,
-        true,
-      )) as [ExtensionRow[], number];
-      expect(count).toBe(1);
-      expect(grid).toEqual([expect.objectContaining({ guid: firstGuid })]);
-
-      const updated = await service.updateEntity(
-        { guid: firstGuid },
-        {
-          expectedRevision: 1,
-          priority: 3,
-          enabled: false,
-          label: "first updated",
-        },
-      );
-      expect(updated).toMatchObject({
-        label: "first updated",
-        priority: 3,
-        revision: 2,
-        payload: {
-          retained: true,
-          attributes: { priority: 3, enabled: false },
-        },
-      });
-      await expect(
-        service.updateEntity(
-          { guid: firstGuid },
-          { expectedRevision: 1, label: "stale" },
-        ),
-      ).rejects.toThrow("stale");
-
-      const owners = dataSource.getRepository(OmniRecordEntity);
-      await owners.insert({
-        scopeId: alphaScope.scopeId,
-        guid: thirdGuid,
-        title: "Other owner",
-        kind: "other_extension",
-        status: OmniRecordStatus.Active,
-        payloadSchemaId: "other.extension.v1",
-        payloadSchemaVersion: 1,
-      });
-      expect(await service.getEntity({ guid: thirdGuid })).toBeNull();
-    });
-
-    it("rolls back owner creation when the extension insert fails and cascades extension cleanup on delete", async () => {
-      await service.createEntity({
-        guid: firstGuid,
-        label: "unique label",
-        priority: 1,
-        enabled: true,
-      });
-      const extensions = dataSource.getRepository<ExtensionRow>(extensionEntity);
-      await dataSource.query(
-        `CREATE UNIQUE INDEX "example_extension_projection_label_unique" ON "${definition.tableName}" ("label")`,
-      );
-      await expect(
-        service.createEntity({
-          guid: secondGuid,
-          label: "unique label",
-          priority: 2,
-          enabled: false,
-        }),
-      ).rejects.toThrow("already exists");
-      expect(
-        await dataSource.getRepository(OmniRecordEntity).findOneBy({
-          scopeId: alphaScope.scopeId,
-          guid: secondGuid,
-        }),
-      ).toBeNull();
-
-      await service.deleteEntity({ guid: firstGuid });
-      expect(
-        await dataSource.getRepository(OmniRecordEntity).countBy({
-          scopeId: alphaScope.scopeId,
-          guid: firstGuid,
-        }),
-      ).toBe(0);
-      expect(
-        await extensions.countBy({
-          scopeId: alphaScope.scopeId,
-          guid: firstGuid,
-        }),
-      ).toBe(0);
-    });
-
-    it("rolls back the owner revision when the extension row disappears during a patch", async () => {
-      await service.createEntity({
-        guid: firstGuid,
-        label: "rollback candidate",
-        priority: 1,
-        enabled: true,
-      });
-      const patchValues = jest
-        .spyOn(dialect, "patchValues")
-        .mockResolvedValue(0);
-
-      await expect(
-        service.updateEntity(
-          { guid: firstGuid },
-          { expectedRevision: 1, label: "must roll back" },
-        ),
-      ).rejects.toThrow("extension row is unavailable");
-      expect(
-        await dataSource.getRepository(OmniRecordEntity).findOneByOrFail({
-          scopeId: alphaScope.scopeId,
-          guid: firstGuid,
-        }),
-      ).toMatchObject({ revision: 1 });
-      patchValues.mockRestore();
-    });
-
-    it("uses one generic relation table with fixed registered endpoint semantics and validates reusable external-ref targets", async () => {
-      await service.createEntity({
-        guid: firstGuid,
-        label: "source",
-        priority: 1,
-        enabled: true,
-      });
-      await service.createEntity({
-        guid: secondGuid,
-        label: "target",
-        priority: 2,
-        enabled: false,
-      });
-      await bravoService.createEntity({
-        guid: bravoOnlyGuid,
-        label: "bravo only",
-        priority: 3,
-        enabled: true,
-      });
-      const records = dataSource.getRepository(OmniRecordEntity);
-      const relations = new OmniRelationProjectionService(
-        dataSource.getRepository(OmniRelationEntity) as never,
-        alphaScope,
-        "hard",
-        records,
-        createOmniRelationKindContract(["links"]),
-        relationDefinition,
-      );
-      const relationGuid = "10000000-0000-4000-8000-000000000010";
-      await relations.createEntity({
-        guid: relationGuid,
-        sourceRecordId: firstGuid,
-        targetRecordId: secondGuid,
-        payload: { strength: 1 },
-      });
-      await expect(
-        relations.createEntity({
-          guid: "10000000-0000-4000-8000-000000000011",
-          sourceRecordId: firstGuid,
-          targetRecordId: bravoOnlyGuid,
-        }),
-      ).rejects.toThrow("not found");
-      await expect(
-        relations.createEntity({
-          guid: "10000000-0000-4000-8000-000000000012",
-          sourceRecordId: firstGuid,
-          targetRecordId: secondGuid,
-        }),
-      ).rejects.toThrow();
-      await expect(
-        relations.createEntity({
-          guid: "10000000-0000-4000-8000-000000000013",
-          sourceRecordId: firstGuid,
-          targetRecordId: secondGuid,
-          kind: "links",
-        }),
-      ).rejects.toThrow("server-owned");
-      const otherRelationGuid = "10000000-0000-4000-8000-000000000014";
-      await dataSource.getRepository(OmniRelationEntity).insert({
-        scopeId: alphaScope.scopeId,
-        guid: otherRelationGuid,
-        sourceRecordId: firstGuid,
-        targetRecordId: secondGuid,
-        kind: "other_link",
-        status: "active",
-        payloadSchemaId: "other.link.v1",
-        payloadSchemaVersion: 1,
-      });
-      const otherSchemaRelationGuid =
-        "10000000-0000-4000-8000-000000000015";
-      await dataSource.getRepository(OmniRelationEntity).insert({
-        scopeId: alphaScope.scopeId,
-        guid: otherSchemaRelationGuid,
-        sourceRecordId: secondGuid,
-        targetRecordId: firstGuid,
-        kind: "links",
-        status: "active",
-        payloadSchemaId: "other.link.v1",
-        payloadSchemaVersion: 1,
-      });
-      expect(
-        await relations.getEntity({ guid: otherRelationGuid }),
-      ).toBeNull();
-      expect(await relations.getEntity(otherRelationGuid as never)).toBeNull();
-      expect(
-        await relations.getEntity({ guid: otherSchemaRelationGuid }),
-      ).toBeNull();
-      await expect(
-        relations.getEntity({ guid: relationGuid, kind: "links" } as never),
-      ).rejects.toThrow("server-owned");
-      await expect(
-        relations.updateEntity(
-          { guid: otherRelationGuid },
-          { payload: { no: true } },
-        ),
-      ).rejects.toThrow();
-      await expect(
-        relations.deleteEntity({ guid: otherRelationGuid }),
-      ).rejects.toThrow();
-      await expect(
-        relations.getEntityListExtended({
-          where: { filters: { kind: "other_link" } },
-        } as never),
-      ).rejects.toThrow("server-owned");
-      await expect(
-        relations.updateEntity(
-          { guid: relationGuid, kind: "links" } as never,
-          { payload: { no: true }, expectedRevision: 1 },
-        ),
-      ).rejects.toThrow("server-owned");
-      await expect(
-        relations.deleteEntity({ guid: relationGuid, kind: "links" } as never),
-      ).rejects.toThrow("server-owned");
-      expect(await relations.getEntityListExtended({})).toEqual([
-        expect.objectContaining({ guid: relationGuid }),
-      ]);
-      expect(
-        dataSource.entityMetadatas.filter(
-          (metadata) => metadata.tableName === "omni-relation",
-        ),
-      ).toHaveLength(1);
-
-      const validator = new OmniExternalRefBindingValidator(
-        records,
-        alphaScope,
-      );
-      await expect(
-        validator.assertTarget({
-          internalId: firstGuid,
-          internalType: OmniExternalRefInternalType.Record,
-        }),
-      ).resolves.toMatchObject({ guid: firstGuid });
-      await expect(
-        new OmniExternalRefBindingValidator(records, bravoScope).assertTarget({
-          internalId: firstGuid,
-          internalType: OmniExternalRefInternalType.Record,
-        }),
-      ).rejects.toThrow("not found");
-
-      const externalRefs = new OmniExternalRefService(
-        dataSource.getRepository(OmniExternalRefEntity) as never,
-        alphaScope,
-        "hard",
-        validator,
-      );
-      const externalRefGuid = "10000000-0000-4000-8000-000000000020";
-      await externalRefs.createEntity({
-        guid: externalRefGuid,
-        provider: "example",
-        externalId: "one",
-        internalType: OmniExternalRefInternalType.Record,
-        internalId: firstGuid,
-      });
-      await expect(
-        externalRefs.createEntity({
-          guid: "10000000-0000-4000-8000-000000000021",
-          provider: "example",
-          externalId: "missing",
-          internalType: OmniExternalRefInternalType.Record,
-          internalId: thirdGuid,
-        }),
-      ).rejects.toThrow("not found");
-      await expect(
-        new OmniExternalRefService(
-          dataSource.getRepository(OmniExternalRefEntity) as never,
-          bravoScope,
-          "hard",
-          new OmniExternalRefBindingValidator(records, bravoScope),
-        ).createEntity({
-          guid: "10000000-0000-4000-8000-000000000022",
-          provider: "example",
-          externalId: "cross-scope",
-          internalType: OmniExternalRefInternalType.Record,
-          internalId: firstGuid,
-        }),
-      ).rejects.toThrow("not found");
-      await expect(
-        externalRefs.updateEntity(
-          { guid: externalRefGuid },
-          { internalId: bravoOnlyGuid },
-        ),
-      ).rejects.toThrow("immutable");
-    });
-
-    it('supports one multi-kind relation surface, public aliases, revisions, and bounded catalog readers', async () => {
-      await service.createEntity({
-        guid: firstGuid,
-        label: 'source',
-        priority: 1,
-        enabled: true,
-      });
-      await service.createEntity({
-        guid: secondGuid,
-        label: 'target',
-        priority: 2,
-        enabled: false,
-      });
-      const multiDefinition = defineOmniRelationProjection({
-        id: 'example.multi-link.v1',
-        relation: {
-          allowedKinds: ['links', 'blocks'],
-          sourceKind: definition.owner.kind,
-          targetKind: definition.owner.kind,
-          schema: { id: 'example.multi-link.v1', version: 1 },
-        },
-        aliases: {
-          kind: 'linkKind',
-          source: 'sourceWorkItemId',
-          target: 'targetWorkItemId',
-          payload: 'metadata',
-        },
-      });
-      const relations = new OmniRelationProjectionService(
-        dataSource.getRepository(OmniRelationEntity),
-        alphaScope,
-        'hard',
-        dataSource.getRepository(OmniRecordEntity),
-        createOmniRelationKindContract(['links', 'blocks']),
-        multiDefinition,
-        dataSource,
-      );
-      const relationGuid = '10000000-0000-4000-8000-000000000030';
-      const relation = await relations.createEntity({
-        guid: relationGuid,
-        linkKind: 'links',
-        sourceWorkItemId: firstGuid,
-        targetWorkItemId: secondGuid,
-        metadata: { enabled: true },
-      } as never);
-      expect(relation).toMatchObject({
-        linkKind: 'links',
-        sourceWorkItemId: firstGuid,
-        targetWorkItemId: secondGuid,
-        metadata: { enabled: true },
-        revision: 1,
-      });
-      await expect(
-        relations.createEntity({
-          guid: '10000000-0000-4000-8000-000000000031',
-          linkKind: 'not_registered',
-          sourceWorkItemId: firstGuid,
-          targetWorkItemId: secondGuid,
-        } as never),
-      ).rejects.toThrow('not allowed');
-      await expect(
-        relations.updateEntity(
-          { guid: relationGuid },
-          { sourceWorkItemId: secondGuid, expectedRevision: 1 } as never,
-        ),
-      ).rejects.toThrow('immutable');
-      const updated = await relations.updateEntity(
-        { guid: relationGuid },
-        { metadata: { enabled: false }, expectedRevision: 1 } as never,
-      );
-      expect(updated).toMatchObject({
-        metadata: { enabled: false },
-        revision: 2,
-      });
-      await expect(
-        relations.updateEntity(
-          { guid: relationGuid },
-          { metadata: { enabled: true }, expectedRevision: 1 } as never,
-        ),
-      ).rejects.toThrow('revision conflict');
-
-      const catalog = createOmniProjectionReaderCatalog([
-        {
-          type: 'extension',
-          id: definition.id,
-          entity: extensionEntity,
-          definition,
-        },
-        {
-          type: 'relation',
-          id: multiDefinition.id,
-          definition: multiDefinition,
-        },
-      ]);
-      const readers = catalog.bind(dataSource.manager, alphaScope);
-      const projectedExtensions = await readers.extension(definition.id).list({
-        where: { label: 'source' },
-        take: 1,
-      });
-      expect(projectedExtensions).toEqual([
-        expect.objectContaining({
-          scopeId: alphaScope.scopeId,
-          guid: firstGuid,
-          label: 'source',
-          revision: 1,
-          createdAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        }),
-      ]);
-      expect(projectedExtensions[0]).not.toHaveProperty('kind');
-      await expect(
-        readers.extension(definition.id).list({ where: { payload: {} } }),
-      ).rejects.toThrow('declared eq fields');
-      await expect(
-        readers.relation(multiDefinition.id).list({
-          sourceRecordId: firstGuid,
-          take: 1,
-        }),
-      ).resolves.toEqual([expect.objectContaining({ guid: relationGuid })]);
-      await expect(
-        readers.relation(multiDefinition.id).list({ take: 0 }),
-      ).rejects.toThrow('take must be an integer');
-    });
-
-    it('maps concurrent revision and lifecycle-predicate writes to one success and one conflict', async () => {
-      const sqlitePath = join(tmpdir(), `omni-projection-race-${randomUUID()}.sqlite`);
-      const options = {
-        type: name,
-        ...(name === 'sqlite'
-          ? { database: sqlitePath }
-          : { url: url!, ssl: false }),
-        entities: [
-          OmniNamedEntity,
-          OmniRecordEntity,
-          OmniRelationEntity,
-          OmniExternalRefEntity,
-          extensionEntity,
-        ],
-      } as const;
-      const primary = new DataSource({
-        ...options,
-        dropSchema: true,
-        synchronize: true,
-      } as never);
-      const secondary = new DataSource({
-        ...options,
-        synchronize: false,
-      } as never);
-      await primary.initialize();
-      await secondary.initialize();
-      try {
-        const first = new OmniExtensionProjectionService(
-          primary.getRepository<ExtensionRow>(extensionEntity),
-          primary.getRepository(OmniRecordEntity),
-          primary,
-          alphaScope,
-          createProjectionDialect(name),
-          events as never,
-          definition,
-        );
-        const second = new OmniExtensionProjectionService(
-          secondary.getRepository<ExtensionRow>(extensionEntity),
-          secondary.getRepository(OmniRecordEntity),
-          secondary,
-          alphaScope,
-          createProjectionDialect(name),
-          events as never,
-          definition,
-        );
-        await first.createEntity({
-          guid: firstGuid,
-          label: 'revision-race',
-          enabled: true,
-        });
-        const revisionOutcomes = await Promise.allSettled([
-          first.updateEntity(
-            { guid: firstGuid },
-            { expectedRevision: 1, label: 'revision race one' },
-          ),
-          second.updateEntity(
-            { guid: firstGuid },
-            { expectedRevision: 1, label: 'revision race two' },
-          ),
-        ]);
-        expect(
-          revisionOutcomes.filter((result) => result.status === 'fulfilled'),
-        ).toHaveLength(1);
-        expect(
-          revisionOutcomes.filter((result) => result.status === 'rejected'),
-        ).toHaveLength(1);
-
-        let waiting = 0;
-        let release: (() => void) | undefined;
-        const gate = new Promise<void>((resolve) => {
-          release = resolve;
-        });
-        const lifecycle = {
-          beforeCreate: async (context: any) => {
-            const existing = await context.readers.extension(definition.id).list({
-              where: { label: 'predicate-singleton' },
-              take: 1,
-            });
-            if (existing.length > 0) {
-              throw new ConflictException('Lifecycle predicate already holds.');
-            }
-            waiting += 1;
-            if (waiting === 2) release?.();
-            await gate;
-          },
-        };
-        const guardedFirst = new OmniExtensionProjectionService(
-          primary.getRepository<ExtensionRow>(extensionEntity),
-          primary.getRepository(OmniRecordEntity),
-          primary,
-          alphaScope,
-          createProjectionDialect(name),
-          events as never,
-          definition,
-          lifecycle,
-        );
-        const guardedSecond = new OmniExtensionProjectionService(
-          secondary.getRepository<ExtensionRow>(extensionEntity),
-          secondary.getRepository(OmniRecordEntity),
-          secondary,
-          alphaScope,
-          createProjectionDialect(name),
-          events as never,
-          definition,
-          lifecycle,
-        );
-        const lifecycleOutcomes = await Promise.allSettled([
-          guardedFirst.createEntity({
-            guid: secondGuid,
-            label: 'predicate-singleton',
-            enabled: true,
-          }),
-          guardedSecond.createEntity({
-            guid: thirdGuid,
-            label: 'predicate-singleton',
-            enabled: false,
-          }),
-        ]);
-        expect(
-          lifecycleOutcomes.filter((result) => result.status === 'fulfilled'),
-        ).toHaveLength(1);
-        expect(
-          lifecycleOutcomes.filter((result) => result.status === 'rejected'),
-        ).toHaveLength(1);
-        expect(
-          lifecycleOutcomes.find(
-            (result): result is PromiseRejectedResult => result.status === 'rejected',
-          )!.reason,
-        ).toBeInstanceOf(ConflictException);
-      } finally {
-        if (secondary.isInitialized) await secondary.destroy();
-        if (primary.isInitialized) {
-          await primary.dropDatabase();
-          await primary.destroy();
-        }
-        if (name === 'sqlite') await rm(sqlitePath, { force: true });
-      }
-    });
-  },
-);
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from "@jest/globals";
+import {
+  BadRequestException,
+  ConflictException,
+  NotFoundException,
+} from "@nestjs/common";
+import {
+  applyProjectionIndexesForBootstrap,
+  createProjectionDialect,
+  type ProjectionDialect,
+} from "@nest-yalc-2/crud-gen";
+import { randomUUID } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DataSource } from "typeorm";
+
+import { OmniNamedEntity } from '../base/omni-named.entity.js';
+import { OmniRecordEntity } from '../base/omni-record.entity.js';
+import { OmniRelationEntity } from '../base/omni-relation.entity.js';
+import { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
+import { OmniExtensionProjectionService } from '../omni-extension-projection.service.js';
+import {
+  createOmniExtensionProjectionEntity,
+  defineOmniExtensionProjection,
+} from '../omni-extension-projection.definition.js';
+import { OmniExternalRefBindingValidator } from '../omni-external-ref-binding.validator.js';
+import { OmniExternalRefService } from '../omni-external-ref.service.js';
+import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
+import { defineOmniRelationProjection } from '../omni-relation-projection.definition.js';
+import { OmniRelationProjectionService } from '../omni-relation-projection.service.js';
+import { createOmniRelationKindContract } from '../omni-relation-kind.contract.js';
+import { createOmniProjectionReaderCatalog } from '../omni-projection.catalog.js';
+import { OmniRecordStatus } from '../omni-record-status.enum.js';
+
+type ExtensionRow = {
+  scopeId: string;
+  guid: string;
+  label: string;
+  payload: Record<string, unknown>;
+  revision?: number;
+  priority?: number | null;
+};
+
+const definition = defineOmniExtensionProjection({
+  id: "example.extension-projection.v1",
+  tableName: "example-extension-projection",
+  identity: { column: "guid", uniqueWithinScope: true },
+  scope: { column: "scopeId", serverOwned: true },
+  revision: { column: "revision" },
+  payload: { column: "payload", allowCreate: true },
+  deletion: "hard",
+  fields: [
+    {
+      name: "guid",
+      storage: "column",
+      column: "guid",
+      codec: "uuid",
+      nullable: false,
+      requiredOnCreate: true,
+    },
+    {
+      name: "label",
+      storage: "column",
+      column: "label",
+      codec: "string",
+      nullable: false,
+      requiredOnCreate: true,
+      query: { filter: ["eq"], sort: true },
+    },
+    {
+      name: "priority",
+      storage: "json",
+      path: ["attributes", "priority"],
+      codec: "integer",
+      nullable: true,
+      query: { filter: ["eq", "range"], sort: true },
+      index: { name: "example_extension_projection_priority_idx" },
+    },
+    {
+      name: "enabled",
+      storage: "json",
+      path: ["attributes", "enabled"],
+      codec: "boolean",
+      nullable: false,
+      requiredOnCreate: true,
+      query: { filter: ["eq"], sort: true },
+      index: { name: "example_extension_projection_enabled_idx" },
+    },
+  ],
+  owner: {
+    kind: "example_extension",
+    title: "Example extension",
+    status: OmniRecordStatus.Active,
+    schema: { id: "example.extension.v1", version: 1 },
+  },
+});
+
+const relationDefinition = defineOmniRelationProjection({
+  id: "example.extension-link.v1",
+  relation: {
+    kind: "links",
+    sourceKind: definition.owner.kind,
+    targetKind: definition.owner.kind,
+    schema: { id: "example.extension-link.v1", version: 1 },
+  },
+});
+
+const alphaScope = {
+  scopeId: "scope-alpha",
+  cacheKey: (key: string) => `scope-alpha:${key}`,
+};
+const bravoScope = {
+  scopeId: "scope-bravo",
+  cacheKey: (key: string) => `scope-bravo:${key}`,
+};
+
+const firstGuid = "10000000-0000-4000-8000-000000000001";
+const secondGuid = "10000000-0000-4000-8000-000000000002";
+const thirdGuid = "10000000-0000-4000-8000-000000000003";
+const bravoOnlyGuid = "10000000-0000-4000-8000-000000000004";
+
+const events = {
+  errorBadRequest: (_event: string, options: any) =>
+    new BadRequestException(options.response.message),
+  errorConflict: (_event: string, options: any) =>
+    new ConflictException(options.response.message),
+  errorNotFound: (_event: string, options: any) =>
+    new NotFoundException(options.response.message),
+};
+
+const postgresUrl = process.env.OMNI_EXTENSION_PROJECTION_POSTGRES_URL;
+const dialectCases: Array<{
+  name: "sqlite" | "postgres";
+  url?: string;
+}> = [
+  { name: "sqlite" },
+  ...(postgresUrl ? [{ name: "postgres" as const, url: postgresUrl }] : []),
+];
+
+describe.each(dialectCases)(
+  "Omni extension projection (%s)",
+  ({ name, url }) => {
+    let dataSource: DataSource;
+    let dialect: ProjectionDialect;
+    let extensionEntity: any;
+    let service: InstanceType<
+      typeof OmniExtensionProjectionService<ExtensionRow>
+    >;
+    let bravoService: InstanceType<
+      typeof OmniExtensionProjectionService<ExtensionRow>
+    >;
+
+    beforeEach(async () => {
+      dialect = createProjectionDialect(name);
+      extensionEntity = createOmniExtensionProjectionEntity<ExtensionRow>(
+        definition,
+        dialect,
+      );
+      dataSource = new DataSource({
+        type: name,
+        ...(name === "sqlite"
+          ? { database: ":memory:" }
+          : { url: url!, ssl: false }),
+        dropSchema: true,
+        synchronize: true,
+        entities: [
+          OmniNamedEntity,
+          OmniRecordEntity,
+          OmniRelationEntity,
+          OmniExternalRefEntity,
+          extensionEntity,
+        ],
+      });
+      await dataSource.initialize();
+      await applyProjectionIndexesForBootstrap(dataSource, dialect, definition);
+      const extensions = dataSource.getRepository<ExtensionRow>(extensionEntity);
+      const owners = dataSource.getRepository(OmniRecordEntity);
+      service = new OmniExtensionProjectionService(
+        extensions,
+        owners,
+        dataSource,
+        alphaScope,
+        dialect,
+        events as never,
+        definition,
+      );
+      bravoService = new OmniExtensionProjectionService(
+        extensions,
+        owners,
+        dataSource,
+        bravoScope,
+        dialect,
+        events as never,
+        definition,
+      );
+    });
+
+    afterEach(async () => {
+      if (dataSource.isInitialized) await dataSource.destroy();
+    });
+
+    it("creates, reads, filters, sorts, patches, and isolates owner identity by scope and kind", async () => {
+      const first = await service.createEntity({
+        guid: firstGuid,
+        label: "first",
+        priority: 2,
+        enabled: true,
+        payload: { retained: true },
+      });
+      await service.createEntity({
+        guid: secondGuid,
+        label: "second",
+        priority: 1,
+        enabled: false,
+      });
+      await bravoService.createEntity({
+        guid: firstGuid,
+        label: "bravo copy",
+        priority: 8,
+        enabled: true,
+      });
+
+      expect(first).toMatchObject({
+        guid: firstGuid,
+        label: "first",
+        priority: 2,
+        revision: 1,
+        payload: { retained: true, attributes: { priority: 2, enabled: true } },
+      });
+      expect(await bravoService.getEntity({ guid: firstGuid })).toMatchObject({
+        label: "bravo copy",
+        priority: 8,
+        enabled: true,
+        revision: 1,
+      });
+      const [grid, count] = (await service.getEntityListExtended(
+        {
+          where: { filters: { priority: 2, enabled: true } },
+          order: { label: "DESC" },
+        } as never,
+        true,
+      )) as [ExtensionRow[], number];
+      expect(count).toBe(1);
+      expect(grid).toEqual([expect.objectContaining({ guid: firstGuid })]);
+
+      const updated = await service.updateEntity(
+        { guid: firstGuid },
+        {
+          expectedRevision: 1,
+          priority: 3,
+          enabled: false,
+          label: "first updated",
+        },
+      );
+      expect(updated).toMatchObject({
+        label: "first updated",
+        priority: 3,
+        revision: 2,
+        payload: {
+          retained: true,
+          attributes: { priority: 3, enabled: false },
+        },
+      });
+      await expect(
+        service.updateEntity(
+          { guid: firstGuid },
+          { expectedRevision: 1, label: "stale" },
+        ),
+      ).rejects.toThrow("stale");
+
+      const owners = dataSource.getRepository(OmniRecordEntity);
+      await owners.insert({
+        scopeId: alphaScope.scopeId,
+        guid: thirdGuid,
+        title: "Other owner",
+        kind: "other_extension",
+        status: OmniRecordStatus.Active,
+        payloadSchemaId: "other.extension.v1",
+        payloadSchemaVersion: 1,
+      });
+      expect(await service.getEntity({ guid: thirdGuid })).toBeNull();
+    });
+
+    it("rolls back owner creation when the extension insert fails and cascades extension cleanup on delete", async () => {
+      await service.createEntity({
+        guid: firstGuid,
+        label: "unique label",
+        priority: 1,
+        enabled: true,
+      });
+      const extensions = dataSource.getRepository<ExtensionRow>(extensionEntity);
+      await dataSource.query(
+        `CREATE UNIQUE INDEX "example_extension_projection_label_unique" ON "${definition.tableName}" ("label")`,
+      );
+      await expect(
+        service.createEntity({
+          guid: secondGuid,
+          label: "unique label",
+          priority: 2,
+          enabled: false,
+        }),
+      ).rejects.toThrow("already exists");
+      expect(
+        await dataSource.getRepository(OmniRecordEntity).findOneBy({
+          scopeId: alphaScope.scopeId,
+          guid: secondGuid,
+        }),
+      ).toBeNull();
+
+      await service.deleteEntity({ guid: firstGuid });
+      expect(
+        await dataSource.getRepository(OmniRecordEntity).countBy({
+          scopeId: alphaScope.scopeId,
+          guid: firstGuid,
+        }),
+      ).toBe(0);
+      expect(
+        await extensions.countBy({
+          scopeId: alphaScope.scopeId,
+          guid: firstGuid,
+        }),
+      ).toBe(0);
+    });
+
+    it("rolls back the owner revision when the extension row disappears during a patch", async () => {
+      await service.createEntity({
+        guid: firstGuid,
+        label: "rollback candidate",
+        priority: 1,
+        enabled: true,
+      });
+      const patchValues = jest
+        .spyOn(dialect, "patchValues")
+        .mockResolvedValue(0);
+
+      await expect(
+        service.updateEntity(
+          { guid: firstGuid },
+          { expectedRevision: 1, label: "must roll back" },
+        ),
+      ).rejects.toThrow("extension row is unavailable");
+      expect(
+        await dataSource.getRepository(OmniRecordEntity).findOneByOrFail({
+          scopeId: alphaScope.scopeId,
+          guid: firstGuid,
+        }),
+      ).toMatchObject({ revision: 1 });
+      patchValues.mockRestore();
+    });
+
+    it("uses one generic relation table with fixed registered endpoint semantics and validates reusable external-ref targets", async () => {
+      await service.createEntity({
+        guid: firstGuid,
+        label: "source",
+        priority: 1,
+        enabled: true,
+      });
+      await service.createEntity({
+        guid: secondGuid,
+        label: "target",
+        priority: 2,
+        enabled: false,
+      });
+      await bravoService.createEntity({
+        guid: bravoOnlyGuid,
+        label: "bravo only",
+        priority: 3,
+        enabled: true,
+      });
+      const records = dataSource.getRepository(OmniRecordEntity);
+      const relations = new OmniRelationProjectionService(
+        dataSource.getRepository(OmniRelationEntity) as never,
+        alphaScope,
+        "hard",
+        records,
+        createOmniRelationKindContract(["links"]),
+        relationDefinition,
+      );
+      const relationGuid = "10000000-0000-4000-8000-000000000010";
+      await relations.createEntity({
+        guid: relationGuid,
+        sourceRecordId: firstGuid,
+        targetRecordId: secondGuid,
+        payload: { strength: 1 },
+      });
+      await expect(
+        relations.createEntity({
+          guid: "10000000-0000-4000-8000-000000000011",
+          sourceRecordId: firstGuid,
+          targetRecordId: bravoOnlyGuid,
+        }),
+      ).rejects.toThrow("not found");
+      await expect(
+        relations.createEntity({
+          guid: "10000000-0000-4000-8000-000000000012",
+          sourceRecordId: firstGuid,
+          targetRecordId: secondGuid,
+        }),
+      ).rejects.toThrow();
+      await expect(
+        relations.createEntity({
+          guid: "10000000-0000-4000-8000-000000000013",
+          sourceRecordId: firstGuid,
+          targetRecordId: secondGuid,
+          kind: "links",
+        }),
+      ).rejects.toThrow("server-owned");
+      const otherRelationGuid = "10000000-0000-4000-8000-000000000014";
+      await dataSource.getRepository(OmniRelationEntity).insert({
+        scopeId: alphaScope.scopeId,
+        guid: otherRelationGuid,
+        sourceRecordId: firstGuid,
+        targetRecordId: secondGuid,
+        kind: "other_link",
+        status: "active",
+        payloadSchemaId: "other.link.v1",
+        payloadSchemaVersion: 1,
+      });
+      const otherSchemaRelationGuid =
+        "10000000-0000-4000-8000-000000000015";
+      await dataSource.getRepository(OmniRelationEntity).insert({
+        scopeId: alphaScope.scopeId,
+        guid: otherSchemaRelationGuid,
+        sourceRecordId: secondGuid,
+        targetRecordId: firstGuid,
+        kind: "links",
+        status: "active",
+        payloadSchemaId: "other.link.v1",
+        payloadSchemaVersion: 1,
+      });
+      expect(
+        await relations.getEntity({ guid: otherRelationGuid }),
+      ).toBeNull();
+      expect(await relations.getEntity(otherRelationGuid as never)).toBeNull();
+      expect(
+        await relations.getEntity({ guid: otherSchemaRelationGuid }),
+      ).toBeNull();
+      await expect(
+        relations.getEntity({ guid: relationGuid, kind: "links" } as never),
+      ).rejects.toThrow("server-owned");
+      await expect(
+        relations.updateEntity(
+          { guid: otherRelationGuid },
+          { payload: { no: true } },
+        ),
+      ).rejects.toThrow();
+      await expect(
+        relations.deleteEntity({ guid: otherRelationGuid }),
+      ).rejects.toThrow();
+      await expect(
+        relations.getEntityListExtended({
+          where: { filters: { kind: "other_link" } },
+        } as never),
+      ).rejects.toThrow("server-owned");
+      await expect(
+        relations.updateEntity(
+          { guid: relationGuid, kind: "links" } as never,
+          { payload: { no: true }, expectedRevision: 1 },
+        ),
+      ).rejects.toThrow("server-owned");
+      await expect(
+        relations.deleteEntity({ guid: relationGuid, kind: "links" } as never),
+      ).rejects.toThrow("server-owned");
+      expect(await relations.getEntityListExtended({})).toEqual([
+        expect.objectContaining({ guid: relationGuid }),
+      ]);
+      expect(
+        dataSource.entityMetadatas.filter(
+          (metadata) => metadata.tableName === "omni-relation",
+        ),
+      ).toHaveLength(1);
+
+      const validator = new OmniExternalRefBindingValidator(
+        records,
+        alphaScope,
+      );
+      await expect(
+        validator.assertTarget({
+          internalId: firstGuid,
+          internalType: OmniExternalRefInternalType.Record,
+        }),
+      ).resolves.toMatchObject({ guid: firstGuid });
+      await expect(
+        new OmniExternalRefBindingValidator(records, bravoScope).assertTarget({
+          internalId: firstGuid,
+          internalType: OmniExternalRefInternalType.Record,
+        }),
+      ).rejects.toThrow("not found");
+
+      const externalRefs = new OmniExternalRefService(
+        dataSource.getRepository(OmniExternalRefEntity) as never,
+        alphaScope,
+        "hard",
+        validator,
+      );
+      const externalRefGuid = "10000000-0000-4000-8000-000000000020";
+      await externalRefs.createEntity({
+        guid: externalRefGuid,
+        provider: "example",
+        externalId: "one",
+        internalType: OmniExternalRefInternalType.Record,
+        internalId: firstGuid,
+      });
+      await expect(
+        externalRefs.createEntity({
+          guid: "10000000-0000-4000-8000-000000000021",
+          provider: "example",
+          externalId: "missing",
+          internalType: OmniExternalRefInternalType.Record,
+          internalId: thirdGuid,
+        }),
+      ).rejects.toThrow("not found");
+      await expect(
+        new OmniExternalRefService(
+          dataSource.getRepository(OmniExternalRefEntity) as never,
+          bravoScope,
+          "hard",
+          new OmniExternalRefBindingValidator(records, bravoScope),
+        ).createEntity({
+          guid: "10000000-0000-4000-8000-000000000022",
+          provider: "example",
+          externalId: "cross-scope",
+          internalType: OmniExternalRefInternalType.Record,
+          internalId: firstGuid,
+        }),
+      ).rejects.toThrow("not found");
+      await expect(
+        externalRefs.updateEntity(
+          { guid: externalRefGuid },
+          { internalId: bravoOnlyGuid },
+        ),
+      ).rejects.toThrow("immutable");
+    });
+
+    it('supports one multi-kind relation surface, public aliases, revisions, and bounded catalog readers', async () => {
+      await service.createEntity({
+        guid: firstGuid,
+        label: 'source',
+        priority: 1,
+        enabled: true,
+      });
+      await service.createEntity({
+        guid: secondGuid,
+        label: 'target',
+        priority: 2,
+        enabled: false,
+      });
+      const multiDefinition = defineOmniRelationProjection({
+        id: 'example.multi-link.v1',
+        relation: {
+          allowedKinds: ['links', 'blocks'],
+          sourceKind: definition.owner.kind,
+          targetKind: definition.owner.kind,
+          schema: { id: 'example.multi-link.v1', version: 1 },
+        },
+        aliases: {
+          kind: 'linkKind',
+          source: 'sourceWorkItemId',
+          target: 'targetWorkItemId',
+          payload: 'metadata',
+        },
+      });
+      const relations = new OmniRelationProjectionService(
+        dataSource.getRepository(OmniRelationEntity),
+        alphaScope,
+        'hard',
+        dataSource.getRepository(OmniRecordEntity),
+        createOmniRelationKindContract(['links', 'blocks']),
+        multiDefinition,
+        dataSource,
+      );
+      const relationGuid = '10000000-0000-4000-8000-000000000030';
+      const relation = await relations.createEntity({
+        guid: relationGuid,
+        linkKind: 'links',
+        sourceWorkItemId: firstGuid,
+        targetWorkItemId: secondGuid,
+        metadata: { enabled: true },
+      } as never);
+      expect(relation).toMatchObject({
+        linkKind: 'links',
+        sourceWorkItemId: firstGuid,
+        targetWorkItemId: secondGuid,
+        metadata: { enabled: true },
+        revision: 1,
+      });
+      await expect(
+        relations.createEntity({
+          guid: '10000000-0000-4000-8000-000000000031',
+          linkKind: 'not_registered',
+          sourceWorkItemId: firstGuid,
+          targetWorkItemId: secondGuid,
+        } as never),
+      ).rejects.toThrow('not allowed');
+      await expect(
+        relations.updateEntity(
+          { guid: relationGuid },
+          { sourceWorkItemId: secondGuid, expectedRevision: 1 } as never,
+        ),
+      ).rejects.toThrow('immutable');
+      const updated = await relations.updateEntity(
+        { guid: relationGuid },
+        { metadata: { enabled: false }, expectedRevision: 1 } as never,
+      );
+      expect(updated).toMatchObject({
+        metadata: { enabled: false },
+        revision: 2,
+      });
+      await expect(
+        relations.updateEntity(
+          { guid: relationGuid },
+          { metadata: { enabled: true }, expectedRevision: 1 } as never,
+        ),
+      ).rejects.toThrow('revision conflict');
+
+      const catalog = createOmniProjectionReaderCatalog([
+        {
+          type: 'extension',
+          id: definition.id,
+          entity: extensionEntity,
+          definition,
+        },
+        {
+          type: 'relation',
+          id: multiDefinition.id,
+          definition: multiDefinition,
+        },
+      ]);
+      const readers = catalog.bind(dataSource.manager, alphaScope);
+      const projectedExtensions = await readers.extension(definition.id).list({
+        where: { label: 'source' },
+        take: 1,
+      });
+      expect(projectedExtensions).toEqual([
+        expect.objectContaining({
+          scopeId: alphaScope.scopeId,
+          guid: firstGuid,
+          label: 'source',
+          revision: 1,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        }),
+      ]);
+      expect(projectedExtensions[0]).not.toHaveProperty('kind');
+      await expect(
+        readers.extension(definition.id).list({ where: { payload: {} } }),
+      ).rejects.toThrow('declared eq fields');
+      await expect(
+        readers.relation(multiDefinition.id).list({
+          sourceRecordId: firstGuid,
+          take: 1,
+        }),
+      ).resolves.toEqual([expect.objectContaining({ guid: relationGuid })]);
+      await expect(
+        readers.relation(multiDefinition.id).list({ take: 0 }),
+      ).rejects.toThrow('take must be an integer');
+    });
+
+    it('maps concurrent revision and lifecycle-predicate writes to one success and one conflict', async () => {
+      const sqlitePath = join(tmpdir(), `omni-projection-race-${randomUUID()}.sqlite`);
+      const options = {
+        type: name,
+        ...(name === 'sqlite'
+          ? { database: sqlitePath }
+          : { url: url!, ssl: false }),
+        entities: [
+          OmniNamedEntity,
+          OmniRecordEntity,
+          OmniRelationEntity,
+          OmniExternalRefEntity,
+          extensionEntity,
+        ],
+      } as const;
+      const primary = new DataSource({
+        ...options,
+        dropSchema: true,
+        synchronize: true,
+      } as never);
+      const secondary = new DataSource({
+        ...options,
+        synchronize: false,
+      } as never);
+      await primary.initialize();
+      await secondary.initialize();
+      try {
+        const first = new OmniExtensionProjectionService(
+          primary.getRepository<ExtensionRow>(extensionEntity),
+          primary.getRepository(OmniRecordEntity),
+          primary,
+          alphaScope,
+          createProjectionDialect(name),
+          events as never,
+          definition,
+        );
+        const second = new OmniExtensionProjectionService(
+          secondary.getRepository<ExtensionRow>(extensionEntity),
+          secondary.getRepository(OmniRecordEntity),
+          secondary,
+          alphaScope,
+          createProjectionDialect(name),
+          events as never,
+          definition,
+        );
+        await first.createEntity({
+          guid: firstGuid,
+          label: 'revision-race',
+          enabled: true,
+        });
+        const revisionOutcomes = await Promise.allSettled([
+          first.updateEntity(
+            { guid: firstGuid },
+            { expectedRevision: 1, label: 'revision race one' },
+          ),
+          second.updateEntity(
+            { guid: firstGuid },
+            { expectedRevision: 1, label: 'revision race two' },
+          ),
+        ]);
+        expect(
+          revisionOutcomes.filter((result) => result.status === 'fulfilled'),
+        ).toHaveLength(1);
+        expect(
+          revisionOutcomes.filter((result) => result.status === 'rejected'),
+        ).toHaveLength(1);
+
+        let waiting = 0;
+        let release: (() => void) | undefined;
+        const gate = new Promise<void>((resolve) => {
+          release = resolve;
+        });
+        const lifecycle = {
+          beforeCreate: async (context: any) => {
+            const existing = await context.readers.extension(definition.id).list({
+              where: { label: 'predicate-singleton' },
+              take: 1,
+            });
+            if (existing.length > 0) {
+              throw new ConflictException('Lifecycle predicate already holds.');
+            }
+            waiting += 1;
+            if (waiting === 2) release?.();
+            await gate;
+          },
+        };
+        const guardedFirst = new OmniExtensionProjectionService(
+          primary.getRepository<ExtensionRow>(extensionEntity),
+          primary.getRepository(OmniRecordEntity),
+          primary,
+          alphaScope,
+          createProjectionDialect(name),
+          events as never,
+          definition,
+          lifecycle,
+        );
+        const guardedSecond = new OmniExtensionProjectionService(
+          secondary.getRepository<ExtensionRow>(extensionEntity),
+          secondary.getRepository(OmniRecordEntity),
+          secondary,
+          alphaScope,
+          createProjectionDialect(name),
+          events as never,
+          definition,
+          lifecycle,
+        );
+        const lifecycleOutcomes = await Promise.allSettled([
+          guardedFirst.createEntity({
+            guid: secondGuid,
+            label: 'predicate-singleton',
+            enabled: true,
+          }),
+          guardedSecond.createEntity({
+            guid: thirdGuid,
+            label: 'predicate-singleton',
+            enabled: false,
+          }),
+        ]);
+        expect(
+          lifecycleOutcomes.filter((result) => result.status === 'fulfilled'),
+        ).toHaveLength(1);
+        expect(
+          lifecycleOutcomes.filter((result) => result.status === 'rejected'),
+        ).toHaveLength(1);
+        expect(
+          lifecycleOutcomes.find(
+            (result): result is PromiseRejectedResult => result.status === 'rejected',
+          )!.reason,
+        ).toBeInstanceOf(ConflictException);
+      } finally {
+        if (secondary.isInitialized) await secondary.destroy();
+        if (primary.isInitialized) {
+          await primary.dropDatabase();
+          await primary.destroy();
+        }
+        if (name === 'sqlite') await rm(sqlitePath, { force: true });
+      }
+    });
+  },
+);