@ontrails/warden 1.0.0-beta.4 → 1.0.0-beta.42

package/src/trails/deprecation-without-guidance.trail.ts

@@ -0,0 +1,21 @@
+import { topo } from '@ontrails/core';
+import { deriveTopoGraph } from '@ontrails/topography';
+
+import { deprecationWithoutGuidance } from '../rules/trail-versioning-topo.js';
+import { wrapTopoRule } from './wrap-rule.js';
+
+const emptyTopo = topo('deprecation-without-guidance-clean', {});
+
+export const deprecationWithoutGuidanceTrail = wrapTopoRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        graph: deriveTopoGraph(emptyTopo),
+        topo: emptyTopo,
+      },
+      name: 'No deprecated version entries passes',
+    },
+  ],
+  rule: deprecationWithoutGuidance,
+});

package/src/trails/draft-file-marking.trail.ts

@@ -0,0 +1,16 @@
+import { draftFileMarking } from '../rules/draft-file-marking.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const draftFileMarkingTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `export const id = "notes.list";`,
+      },
+      name: 'File without draft ids passes',
+    },
+  ],
+  rule: draftFileMarking,
+});

package/src/trails/draft-visible-debt.trail.ts

@@ -0,0 +1,16 @@
+import { draftVisibleDebt } from '../rules/draft-visible-debt.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const draftVisibleDebtTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `export const id = "notes.list";`,
+      },
+      name: 'File without draft ids emits no visible-debt diagnostics',
+    },
+  ],
+  rule: draftVisibleDebt,
+});

package/src/trails/duplicate-exported-symbol.trail.ts

@@ -0,0 +1,48 @@
+import { duplicateExportedSymbol } from '../rules/duplicate-exported-symbol.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const duplicateExportedSymbolTrail = wrapRule({
+  examples: [
+    {
+      expected: {
+        diagnostics: [
+          {
+            filePath: '/repo/packages/core/src/index.ts',
+            line: 1,
+            message:
+              'Exported symbol "createClient" is defined by @ontrails/core and also by @ontrails/store (/repo/packages/store/src/index.ts:1). Keep one package as the owner, rename one side, or document a deliberate ownership mirror before exporting both symbols.',
+            rule: 'duplicate-exported-symbol',
+            severity: 'warn',
+          },
+        ],
+      },
+      input: {
+        exportedSymbolDefinitionsByName: {
+          createClient: [
+            {
+              filePath: '/repo/packages/core/src/index.ts',
+              kind: 'function',
+              line: 1,
+              name: 'createClient',
+              workspaceName: '@ontrails/core',
+              workspaceRoot: '/repo/packages/core',
+            },
+            {
+              filePath: '/repo/packages/store/src/index.ts',
+              kind: 'function',
+              line: 1,
+              name: 'createClient',
+              workspaceName: '@ontrails/store',
+              workspaceRoot: '/repo/packages/store',
+            },
+          ],
+        },
+        filePath: '/repo/packages/core/src/index.ts',
+        knownTrailIds: [],
+        sourceCode: 'export function createClient() {}',
+      },
+      name: 'Flags duplicate exported symbol definitions across packages',
+    },
+  ],
+  rule: duplicateExportedSymbol,
+});

package/src/trails/duplicate-public-contract.trail.ts

@@ -0,0 +1,47 @@
+import { Result, topo, trail } from '@ontrails/core';
+import { z } from 'zod';
+
+import { duplicatePublicContract } from '../rules/duplicate-public-contract.js';
+import { wrapTopoRule } from './wrap-rule.js';
+
+const sharedInput = z.object({ target: z.string() });
+const sharedOutput = z.object({ ok: z.boolean() });
+
+const canonicalTrail = trail('survey.diff', {
+  implementation: () => Result.ok({ ok: true }),
+  input: sharedInput,
+  output: sharedOutput,
+});
+
+const duplicateTrail = trail('diff', {
+  implementation: () => Result.ok({ ok: true }),
+  input: sharedInput,
+  output: sharedOutput,
+});
+
+export const duplicatePublicContractTrail = wrapTopoRule({
+  examples: [
+    {
+      expected: {
+        diagnostics: [
+          {
+            filePath: '<topo>',
+            line: 1,
+            message:
+              'Likely duplicate public trail contracts "diff", "survey.diff" share the same input, output, intent, permits, resources, entities, composes, signals, and detours. Keep one contract with aliases/input mappings, compose a distinct wrapper, or document why these public contracts are separate.',
+            rule: 'duplicate-public-contract',
+            severity: 'warn',
+          },
+        ],
+      },
+      input: {
+        topo: topo('duplicate-public-contract', {
+          canonicalTrail,
+          duplicateTrail,
+        }),
+      },
+      name: 'Duplicate public surface contracts are coached',
+    },
+  ],
+  rule: duplicatePublicContract,
+});

package/src/trails/entity-exists.trail.ts

@@ -0,0 +1,21 @@
+import { entityExists } from '../rules/entity-exists.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const entityExistsTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'entity.ts',
+        knownEntityIds: ['user'],
+        knownTrailIds: ['user.create'],
+        sourceCode: `trail("user.create", {
+  entities: [user],
+  implementation: async (input, ctx) => Result.ok({ ok: true }),
+})`,
+      },
+      name: 'Declared entities resolve to known project entities',
+    },
+  ],
+  rule: entityExists,
+});

package/src/trails/error-mapping-completeness.trail.ts

@@ -0,0 +1,30 @@
+import { errorMappingCompleteness } from '../rules/error-mapping-completeness.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const errorMappingCompletenessTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'surface-error-map.ts',
+        sourceCode: `import { createSurfaceErrorMapper } from "@ontrails/core";
+
+const cliMapper = createSurfaceErrorMapper({
+  auth: 9,
+  cancelled: 130,
+  conflict: 3,
+  internal: 8,
+  network: 7,
+  not_found: 2,
+  permission: 4,
+  rate_limit: 6,
+  shift: 10,
+  timeout: 5,
+  validation: 1,
+});`,
+      },
+      name: 'Complete surface error mapper',
+    },
+  ],
+  rule: errorMappingCompleteness,
+});

package/src/trails/example-valid.trail.ts

@@ -0,0 +1,25 @@
+import { exampleValid } from '../rules/example-valid.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const exampleValidTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'entities.ts',
+        sourceCode: `const user = entity("user", {
+  id: z.string().uuid(),
+  name: z.string(),
+}, {
+  examples: [{
+    id: "550e8400-e29b-41d4-a716-446655440000",
+    name: "Ada",
+  }],
+  identity: "id",
+});`,
+      },
+      name: 'Entity examples validate against their schema',
+    },
+  ],
+  rule: exampleValid,
+});

package/src/trails/fires-declarations.trail.ts

@@ -0,0 +1,23 @@
+import { firesDeclarations } from '../rules/fires-declarations.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const firesDeclarationsTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `const entityCreated = signal("entity.created", { payload: z.object({}) });
+trail("entity.onboard", {
+  fires: [entityCreated],
+  implementation: async (input, ctx) => {
+    await ctx.fire(entityCreated, { id: input.id });
+    return Result.ok({});
+  }
+})`,
+      },
+      name: 'Matched fires declarations and calls',
+    },
+  ],
+  rule: firesDeclarations,
+});

package/src/trails/fork-without-preserved-implementation.trail.ts

@@ -0,0 +1,31 @@
+import { forkWithoutPreservedImplementation } from '../rules/trail-versioning-source.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const forkWithoutPreservedImplementationTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'src/trails/versioned.ts',
+        sourceCode: `
+trail('versioned.clean', {
+  version: 2,
+  versions: {
+    1: {
+      input: z.object({ name: z.string() }),
+      output: z.object({ message: z.string() }),
+      transpose: {
+        input: ({ input }) => input,
+        output: ({ output }) => output,
+      },
+    },
+  },
+  implementation: async () => Result.ok({ message: 'ok' }),
+});
+`,
+      },
+      name: 'Revision entries use transpose',
+    },
+  ],
+  rule: forkWithoutPreservedImplementation,
+});

package/src/trails/governed-symbol-residue.trail.ts

@@ -0,0 +1,24 @@
+import { governedSymbolResidue } from '../rules/governed-symbol-residue.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const governedSymbolResidueTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'packages/example/src/trails/play.ts',
+        sourceCode: 'const composeInput = { id: "track" };\n',
+      },
+      name: 'Current governed symbol vocabulary is clean',
+    },
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'packages/example/src/trails/play.ts',
+        sourceCode: 'const crossInput = { id: "track" };\n',
+      },
+      name: 'Cross-compose vocabulary is owned by the beta.19 rule',
+    },
+  ],
+  rule: governedSymbolResidue,
+});

package/src/trails/implementation-returns-result.trail.ts

@@ -0,0 +1,20 @@
+import { implementationReturnsResult } from '../rules/implementation-returns-result.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const implementationReturnsResultTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `trail("entity.show", {
+  implementation: async (input, ctx) => {
+    return Result.ok({ name: "test" });
+  }
+})`,
+      },
+      name: 'Implementation returning Result.ok()',
+    },
+  ],
+  rule: implementationReturnsResult,
+});

package/src/trails/incomplete-accessor-for-standard-op.trail.ts

@@ -0,0 +1,76 @@
+import { resource, Result, topo, trail } from '@ontrails/core';
+import { z } from 'zod';
+
+import { incompleteAccessorForStandardOp } from '../rules/incomplete-accessor-for-standard-op.js';
+import { wrapTopoRule } from './wrap-rule.js';
+
+type Accessor = Readonly<Record<string, (...args: unknown[]) => unknown>>;
+type Connection = Readonly<Record<string, Accessor>>;
+
+const noop = (): undefined => undefined;
+
+const buildResource = (id: string, entityName: string, accessor: Accessor) =>
+  resource<Connection>(id, {
+    create: () => Result.ok({ [entityName]: accessor }),
+    mock: () => ({ [entityName]: accessor }),
+  });
+
+const buildCrudTrail = (
+  trailId: string,
+  resourceValue: ReturnType<typeof buildResource>
+) =>
+  trail(trailId, {
+    implementation: () => Result.ok({ ok: true }),
+    input: z.object({}),
+    output: z.object({ ok: z.boolean() }),
+    pattern: 'crud',
+    resources: [resourceValue],
+  });
+
+const cleanResource = buildResource('store.note.clean', 'note', {
+  insert: noop,
+});
+const warningResource = buildResource('store.note.warn', 'note', {
+  upsert: noop,
+});
+
+const cleanTopo = topo('trl-269-clean', {
+  noteCreate: buildCrudTrail('note.create', cleanResource),
+  noteResource: cleanResource,
+});
+
+const warningTopo = topo('trl-269-warning', {
+  noteCreate: buildCrudTrail('note.create', warningResource),
+  noteResource: warningResource,
+});
+
+export const incompleteAccessorForStandardOpTrail = wrapTopoRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        topo: cleanTopo,
+      },
+      name: 'Preferred accessors keep CRUD trails quiet',
+    },
+    {
+      expected: {
+        diagnostics: [
+          {
+            filePath: '<topo>',
+            line: 1,
+            message:
+              'Trail "note.create" (crud.create): resource "store.note.warn" accessor "note" is missing preferred method "insert"; falls back to "upsert"',
+            rule: 'incomplete-accessor-for-standard-op',
+            severity: 'warn',
+          },
+        ],
+      },
+      input: {
+        topo: warningTopo,
+      },
+      name: 'Fallback-only create accessors emit a warning',
+    },
+  ],
+  rule: incompleteAccessorForStandardOp,
+});

package/src/trails/incomplete-crud.trail.ts

@@ -0,0 +1,39 @@
+import { incompleteCrud } from '../rules/incomplete-crud.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const incompleteCrudTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `import { Result, resource } from '@ontrails/core';
+import { store } from '@ontrails/store';
+import { crud } from '@ontrails/store/trails';
+import { z } from 'zod';
+
+const db = store({
+  notes: {
+    identity: 'id',
+    schema: z.object({
+      id: z.string(),
+      title: z.string(),
+    }),
+  },
+});
+
+const notesResource = resource('db.notes', {
+  create: () => Result.ok({}),
+  mock: () => ({}),
+});
+
+const [createNote, readNote, updateNote, deleteNote, listNote] = crud(
+  db.tables.notes,
+  notesResource
+);`,
+      },
+      name: 'Full CRUD coverage stays quiet',
+    },
+  ],
+  rule: incompleteCrud,
+});

package/src/trails/index.ts

@@ -0,0 +1,89 @@
+export { activationOrphanTrail } from './activation-orphan.trail.js';
+export { capturedKernelTrail } from './captured-kernel.trail.js';
+export { cliCommandRouteCoherenceTrail } from './cli-command-route-coherence.trail.js';
+export { circularRefsTrail } from './circular-refs.trail.js';
+export { entityExistsTrail } from './entity-exists.trail.js';
+export { contextNoSurfaceTypesTrail } from './context-no-surface-types.trail.js';
+export { composesDeclarationsTrail } from './composes-declarations.trail.js';
+export { deadInternalTrailTrail } from './dead-internal-trail.trail.js';
+export { deadPublicTrailTrail } from './dead-public-trail.trail.js';
+export { deprecationWithoutGuidanceTrail } from './deprecation-without-guidance.trail.js';
+export { duplicatePublicContractTrail } from './duplicate-public-contract.trail.js';
+export { draftFileMarkingTrail } from './draft-file-marking.trail.js';
+export { draftVisibleDebtTrail } from './draft-visible-debt.trail.js';
+export { duplicateExportedSymbolTrail } from './duplicate-exported-symbol.trail.js';
+export { errorMappingCompletenessTrail } from './error-mapping-completeness.trail.js';
+export { exampleValidTrail } from './example-valid.trail.js';
+export { firesDeclarationsTrail } from './fires-declarations.trail.js';
+export { forkWithoutPreservedImplementationTrail } from './fork-without-preserved-implementation.trail.js';
+export { governedSymbolResidueTrail } from './governed-symbol-residue.trail.js';
+export { implementationReturnsResultTrail } from './implementation-returns-result.trail.js';
+export { incompleteAccessorForStandardOpTrail } from './incomplete-accessor-for-standard-op.trail.js';
+export { incompleteCrudTrail } from './incomplete-crud.trail.js';
+export { intentPropagationTrail } from './intent-propagation.trail.js';
+export { layerFieldNameDriftTrail } from './layer-field-name-drift.trail.js';
+export { libraryProjectionCoherenceTrail } from './library-projection-coherence.trail.js';
+export { markerSchemaUnsupportedTrail } from './marker-schema-unsupported.trail.js';
+export { missingVisibilityTrail } from './missing-visibility.trail.js';
+export { missingReconcileTrail } from './missing-reconcile.trail.js';
+export { onReferencesExistTrail } from './on-references-exist.trail.js';
+export { noDevPermitInSourceTrail } from './no-dev-permit-in-source.trail.js';
+export { noDestructuredComposeTrail } from './no-destructured-compose.trail.js';
+export { noLegacyCliAliasExportTrail } from './no-legacy-cli-alias-export.trail.js';
+export { noLegacyLayerImportsTrail } from './no-legacy-layer-imports.trail.js';
+export { noDirectImplementationCallTrail } from './no-direct-implementation-call.trail.js';
+export { noNativeErrorResultTrail } from './no-native-error-result.trail.js';
+export { noRedundantResultErrorWrapTrail } from './no-redundant-result-error-wrap.trail.js';
+export { noRetiredCrossVocabularyTrail } from './no-retired-cross-vocabulary.trail.js';
+export { noSyncResultAssumptionTrail } from './no-sync-result-assumption.trail.js';
+export { noThrowInDetourRecoverTrail } from './no-throw-in-detour-recover.trail.js';
+export { noThrowInImplementationTrail } from './no-throw-in-implementation.trail.js';
+export { noTopLevelSurfaceTrail } from './no-top-level-surface.trail.js';
+export { orphanedSignalTrail } from './orphaned-signal.trail.js';
+export { ownerProjectionParityTrail } from './owner-projection-parity.trail.js';
+export { pendingForceTrail } from './pending-force.trail.js';
+export { permitGovernanceTrail } from './permit-governance.trail.js';
+export { preferSchemaInferenceTrail } from './prefer-schema-inference.trail.js';
+export { publicExportExampleCoverageTrail } from './public-export-example-coverage.trail.js';
+export { publicInternalDeepImportsTrail } from './public-internal-deep-imports.trail.js';
+export { publicOutputSchemaTrail } from './public-output-schema.trail.js';
+export { publicUnionOutputDiscriminantsTrail } from './public-union-output-discriminants.trail.js';
+export { readIntentFiresTrail } from './read-intent-fires.trail.js';
+export { referenceExistsTrail } from './reference-exists.trail.js';
+export { resolvedImportBoundaryTrail } from './resolved-import-boundary.trail.js';
+export { resourceDeclarationsTrail } from './resource-declarations.trail.js';
+export { resourceIdGrammarTrail } from './resource-id-grammar.trail.js';
+export { resourceExistsTrail } from './resource-exists.trail.js';
+export { resourceMockCoverageTrail } from './resource-mock-coverage.trail.js';
+export { scheduledDestroyIntentTrail } from './scheduled-destroy-intent.trail.js';
+export { signalGraphCoachingTrail } from './signal-graph-coaching.trail.js';
+export { staticResourceAccessorPreferenceTrail } from './static-resource-accessor-preference.trail.js';
+export { surfaceOverlayCoherenceTrail } from './surface-overlay-coherence.trail.js';
+export { surfaceTrailheadCoherenceTrail } from './surface-trailhead-coherence.trail.js';
+export { trailForkCoachingTrail } from './trail-fork-coaching.trail.js';
+export { trailheadOverrideDivergenceTrail } from './trailhead-override-divergence.trail.js';
+export { unmaterializedActivationSourceTrail } from './unmaterialized-activation-source.trail.js';
+export { unreachableDetourShadowingTrail } from './unreachable-detour-shadowing.trail.js';
+export { validDetourContractTrail } from './valid-detour-contract.trail.js';
+export { validDescribeRefsTrail } from './valid-describe-refs.trail.js';
+export { versionGapTrail } from './version-gap.trail.js';
+export { versionPinnedComposeTrail } from './version-pinned-compose.trail.js';
+export { versionWithoutExamplesTrail } from './version-without-examples.trail.js';
+export { wardenExportSymmetryTrail } from './warden-export-symmetry.trail.js';
+export { wardenRulesUseAstTrail } from './warden-rules-use-ast.trail.js';
+export { webhookRouteCollisionTrail } from './webhook-route-collision.trail.js';
+
+export {
+  diagnosticSchema,
+  projectAwareRuleInput,
+  ruleInput,
+  ruleOutput,
+  topoAwareRuleInput,
+} from './schema.js';
+export type {
+  ProjectAwareRuleInput,
+  RuleInput,
+  RuleOutput,
+  TopoAwareRuleInput,
+} from './schema.js';
+export { wrapRule, wrapTopoRule } from './wrap-rule.js';

package/src/trails/intent-propagation.trail.ts

@@ -0,0 +1,30 @@
+import { intentPropagation } from '../rules/intent-propagation.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const intentPropagationTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        knownTrailIds: ['entity.read', 'entity.lookup'],
+        sourceCode: `trail('entity.read', {
+  intent: 'read',
+  composes: ['entity.lookup'],
+  implementation: async (_input, ctx) => ctx.compose('entity.lookup', {}),
+});
+
+trail('entity.lookup', {
+  intent: 'read',
+  implementation: async () => Result.ok({}),
+});`,
+        trailIntentsById: {
+          'entity.lookup': 'read',
+          'entity.read': 'read',
+        },
+      },
+      name: 'Read trails may compose other read trails',
+    },
+  ],
+  rule: intentPropagation,
+});

package/src/trails/layer-field-name-drift.trail.ts

@@ -0,0 +1,39 @@
+import { layerFieldNameDrift } from '../rules/layer-field-name-drift.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const layerFieldNameDriftTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'packages/cli/src/build.ts',
+        sourceCode: `import { LAYER_FIELD_RESERVED_NAMES } from '@ontrails/core';
+
+const collides = LAYER_FIELD_RESERVED_NAMES.has('all');
+`,
+      },
+      name: 'Allows shared core reserved-name set',
+    },
+    {
+      expected: {
+        diagnostics: [
+          {
+            filePath: 'packages/cli/src/build.ts',
+            line: 1,
+            message:
+              'layer-field-name-drift: surface-local reserved name set "META_FLAG_CANDIDATES" can make layer input fields project differently across surfaces. Import LAYER_FIELD_RESERVED_NAMES from @ontrails/core instead.',
+            rule: 'layer-field-name-drift',
+            severity: 'error',
+          },
+        ],
+      },
+      input: {
+        filePath: 'packages/cli/src/build.ts',
+        sourceCode: `const META_FLAG_CANDIDATES = new Set(['all']);
+`,
+      },
+      name: 'Flags surface-local reserved-name sets',
+    },
+  ],
+  rule: layerFieldNameDrift,
+});

package/src/trails/library-projection-coherence.trail.ts

@@ -0,0 +1,43 @@
+import { Result, topo, trail } from '@ontrails/core';
+import { z } from 'zod';
+
+import { libraryProjectionCoherence } from '../rules/library-projection-coherence.js';
+import { wrapTopoRule } from './wrap-rule.js';
+
+const output = z.object({ ok: z.boolean() });
+
+const dotted = trail('widget.ping', {
+  implementation: () => Result.ok({ ok: true }),
+  input: z.object({}),
+  output,
+});
+
+const kebab = trail('widget-ping', {
+  implementation: () => Result.ok({ ok: true }),
+  input: z.object({}),
+  output,
+});
+
+export const libraryProjectionCoherenceTrail = wrapTopoRule({
+  examples: [
+    {
+      expected: {
+        diagnostics: [
+          {
+            filePath: '<topo>',
+            line: 1,
+            message:
+              'Library projection export collision on "widgetPing": trails "widget-ping", "widget.ping" derive the same package export. Rename one trail or add a library export override before materializing the generated package.',
+            rule: 'library-projection-coherence',
+            severity: 'error',
+          },
+        ],
+      },
+      input: {
+        topo: topo('library-projection-coherence', { dotted, kebab }),
+      },
+      name: 'Library export collision',
+    },
+  ],
+  rule: libraryProjectionCoherence,
+});