@ontrails/warden 1.0.0-beta.13 → 1.0.0-beta.15

package/src/__tests__/contour-exists.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from 'bun:test';
+
+import { contourExists } from '../rules/contour-exists.js';
+
+const TEST_FILE = 'entity.ts';
+
+describe('contour-exists', () => {
+  describe('local declarations', () => {
+    test('passes when a locally declared contour exists', () => {
+      const code = `
+import { Result, contour, trail } from '@ontrails/core';
+import { z } from 'zod';
+
+const user = contour('user', {
+  id: z.string().uuid(),
+}, { identity: 'id' });
+
+trail('user.create', {
+  contours: [user],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      expect(contourExists.check(code, TEST_FILE)).toEqual([]);
+    });
+
+    test('keeps local contour declarations when project context is present', () => {
+      const code = `
+import { Result, contour, trail } from '@ontrails/core';
+import { z } from 'zod';
+
+const user = contour('user', {
+  id: z.string().uuid(),
+}, { identity: 'id' });
+
+trail('user.create', {
+  contours: [user],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      expect(
+        contourExists.checkWithContext(code, TEST_FILE, {
+          knownContourIds: new Set<string>(),
+          knownTrailIds: new Set(['user.create']),
+        })
+      ).toEqual([]);
+    });
+  });
+
+  describe('named imports', () => {
+    test('flags a missing contour declaration', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import { user } from './contours';
+
+trail('user.create', {
+  contours: [user],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      const diagnostics = contourExists.checkWithContext(code, TEST_FILE, {
+        knownContourIds: new Set<string>(),
+        knownTrailIds: new Set(['user.create']),
+      });
+
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0]?.rule).toBe('contour-exists');
+      expect(diagnostics[0]?.message).toContain('user');
+    });
+
+    test('resolves aliased imports to the original contour name', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import { user as userModel } from './contours';
+
+trail('user.create', {
+  contours: [userModel],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      expect(
+        contourExists.checkWithContext(code, TEST_FILE, {
+          knownContourIds: new Set(['user']),
+          knownTrailIds: new Set(['user.create']),
+        })
+      ).toEqual([]);
+    });
+
+    test('passes when project context includes an imported contour', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import { user } from './contours';
+
+trail('user.create', {
+  contours: [user],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      expect(
+        contourExists.checkWithContext(code, TEST_FILE, {
+          knownContourIds: new Set(['user']),
+          knownTrailIds: new Set(['user.create']),
+        })
+      ).toEqual([]);
+    });
+  });
+
+  describe('default imports', () => {
+    test('flags missing default-imported contour declarations', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import userModel from './contours';
+
+trail('user.create', {
+  contours: [userModel],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      const diagnostics = contourExists.checkWithContext(code, TEST_FILE, {
+        knownContourIds: new Set<string>(),
+        knownTrailIds: new Set(['user.create']),
+      });
+
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0]?.rule).toBe('contour-exists');
+      expect(diagnostics[0]?.message).toContain('userModel');
+    });
+  });
+
+  describe('namespace imports', () => {
+    test('flags missing namespace-imported contour declarations', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import * as contours from './contours';
+
+trail('user.create', {
+  contours: [contours.user],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      const diagnostics = contourExists.checkWithContext(code, TEST_FILE, {
+        knownContourIds: new Set<string>(),
+        knownTrailIds: new Set(['user.create']),
+      });
+
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0]?.rule).toBe('contour-exists');
+      expect(diagnostics[0]?.message).toContain('user');
+    });
+
+    test('resolves namespace-imported contour declarations when known', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import * as contours from './contours';
+
+trail('user.create', {
+  contours: [contours.user],
+  blaze: async () => Result.ok({ ok: true }),
+});
+`;
+
+      expect(
+        contourExists.checkWithContext(code, TEST_FILE, {
+          knownContourIds: new Set(['user']),
+          knownTrailIds: new Set(['user.create']),
+        })
+      ).toEqual([]);
+    });
+
+    test('ignores namespace member access when receiver is shadowed by a local binding', () => {
+      const code = `
+import { Result, trail } from '@ontrails/core';
+import * as contours from './contours';
+
+function makeTrail() {
+  const contours = { user: 'not-a-contour' };
+  return trail('user.create', {
+    contours: [contours.user],
+    blaze: async () => Result.ok({ ok: true }),
+  });
+}
+
+makeTrail();
+`;
+
+      // The trail's \`contours: [contours.user]\` refers to a local
+      // \`const contours = ...\`, not the namespace import, so no
+      // missing-contour diagnostic should be produced.
+      expect(
+        contourExists.checkWithContext(code, TEST_FILE, {
+          knownContourIds: new Set<string>(),
+          knownTrailIds: new Set(['user.create']),
+        })
+      ).toEqual([]);
+    });
+  });
+});

package/src/__tests__/cross-declarations.test.ts

@@ -25,6 +25,26 @@ const t = trail('onboard', {
       expect(diagnostics.length).toBe(0);
     });
 
+    test('resolves batch ctx.cross() calls with string literals', () => {
+      const code = `
+trail('onboard', {
+  crosses: ['entity.add', 'search'],
+  input: z.object({ name: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross([
+      ['entity.add', { name: input.name }],
+      ['search', { query: input.name }],
+    ]);
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
     test('no crosses declaration and no ctx.cross() calls', () => {
       const code = `
 trail('simple', {
@@ -61,6 +81,28 @@ trail('onboard', {
       expect(diagnostics[0]?.message).toContain("ctx.cross('entity.add')");
       expect(diagnostics[0]?.message).toContain('not declared in crosses');
     });
+
+    test('undeclared batch crossings still report an error', () => {
+      const code = `
+trail('onboard', {
+  crosses: ['entity.add'],
+  input: z.object({ name: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross([
+      ['entity.add', { name: input.name }],
+      ['search', { query: input.name }],
+    ]);
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('error');
+      expect(diagnostics[0]?.message).toContain("ctx.cross('search')");
+    });
   });
 
   describe('warn cases', () => {
@@ -176,6 +218,87 @@ trail('onboard', {
 
       expect(diagnostics.length).toBe(0);
     });
+
+    test('blaze with no second parameter: unrelated closure ctx.cross is not tracked', () => {
+      const code = `
+import { trail, Result } from '@ontrails/core';
+
+const ctx = { cross: () => ({}) };
+
+trail('demo', {
+  blaze: async () => {
+    ctx.cross('entity.add');
+    return Result.ok({ ok: true });
+  },
+  crosses: [],
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+      // The blaze has no context parameter, so `ctx` in the body is an
+      // unrelated closure-scoped binding, not the trail context. It must
+      // not be tracked — no diagnostics.
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('blaze with no second parameter: unrelated closure context.cross is not tracked', () => {
+      const code = `
+import { trail, Result } from '@ontrails/core';
+
+const context = { cross: () => ({}) };
+
+trail('demo', {
+  blaze: async () => {
+    context.cross('entity.add');
+    return Result.ok({ ok: true });
+  },
+  crosses: [],
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('real blaze ctx.cross to undeclared target is still flagged', () => {
+      const code = `
+import { trail, Result } from '@ontrails/core';
+
+trail('demo', {
+  blaze: async (_, ctx) => {
+    await ctx.cross('undeclared');
+    return Result.ok({ ok: true });
+  },
+  crosses: [],
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('error');
+      expect(diagnostics[0]?.message).toContain("ctx.cross('undeclared')");
+    });
+
+    test('defaulted context param is detected (AssignmentPattern)', () => {
+      const code = `
+import { trail, Result } from '@ontrails/core';
+
+const fallbackCtx = { cross: async () => Result.ok({}) };
+
+trail('demo', {
+  blaze: async (_input, ctx = fallbackCtx) => {
+    await ctx.cross('undeclared');
+    return Result.ok({ ok: true });
+  },
+  crosses: [],
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('error');
+      expect(diagnostics[0]?.message).toContain("ctx.cross('undeclared')");
+    });
   });
 
   describe('nested run false positives', () => {
@@ -237,6 +360,128 @@ trail('onboard', {
     });
   });
 
+  describe('trail object references in crosses', () => {
+    test('unresolvable identifier in crosses softens undeclared to warn', () => {
+      const code = `
+import { showGist } from '../gist/show';
+trail('gist.fork', {
+  crosses: [showGist],
+  input: z.object({ id: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross('gist.create', { id: input.id });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      // 'gist.create' called but can't prove showGist doesn't cover it
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('warn');
+      expect(diagnostics[0]?.message).toContain('trail object references');
+    });
+
+    test('mixed string and trail object references: resolved string still validated', () => {
+      const code = `
+import { showGist } from '../gist/show';
+trail('gist.fork', {
+  crosses: ['gist.create', showGist],
+  input: z.object({ id: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross('gist.create', { id: input.id });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      // gist.create declared and called — clean. showGist unresolved but declared, not called by string — no unused warning for unresolved entries.
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('trail object only in crosses with no string cross calls is clean', () => {
+      const code = `
+import { showGist } from '../gist/show';
+trail('gist.fork', {
+  crosses: [showGist],
+  input: z.object({ id: z.string() }),
+  blaze: async (input, ctx) => {
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      // No string-resolved IDs and no string cross calls — clean
+      expect(diagnostics.length).toBe(0);
+    });
+  });
+
+  describe('typed ctx.cross(trailObj) calls', () => {
+    test('typed cross call with trail object does not produce undeclared error', () => {
+      const code = `
+import { showGist } from '../gist/show';
+trail('gist.fork', {
+  crosses: [showGist],
+  input: z.object({ id: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross(showGist, { id: input.id });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('typed cross call suppresses unused-declaration warning for matching entry', () => {
+      const code = `
+import { showGist } from '../gist/show';
+trail('gist.fork', {
+  crosses: ['gist.create', showGist],
+  input: z.object({ id: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross('gist.create', { id: input.id });
+    await ctx.cross(showGist, { id: input.id });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      // showGist is unresolvable in crosses but the typed cross call covers it
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('undeclared string cross alongside typed cross still reports error (softened)', () => {
+      const code = `
+import { showGist } from '../gist/show';
+trail('gist.fork', {
+  crosses: [showGist],
+  input: z.object({ id: z.string() }),
+  blaze: async (input, ctx) => {
+    await ctx.cross(showGist, { id: input.id });
+    await ctx.cross('undeclared.trail', { id: input.id });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = crossDeclarations.check(code, TEST_FILE);
+
+      // 'undeclared.trail' not declared — softened because showGist is unresolvable
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('warn');
+      expect(diagnostics[0]?.message).toContain('undeclared.trail');
+    });
+  });
+
   describe('edge cases', () => {
     test('dynamic cross IDs are skipped', () => {
       const code = `

package/src/__tests__/dead-internal-trail.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from 'bun:test';
+
+import { deadInternalTrail } from '../rules/dead-internal-trail.js';
+
+const TEST_FILE = 'entity.ts';
+
+describe('dead-internal-trail', () => {
+  test('warns when an internal trail is never crossed and has no on: activation', () => {
+    const code = `
+trail('entity.sync', {
+  visibility: 'internal',
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    const diagnostics = deadInternalTrail.check(code, TEST_FILE);
+
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.rule).toBe('dead-internal-trail');
+    expect(diagnostics[0]?.severity).toBe('warn');
+    expect(diagnostics[0]?.message).toContain('entity.sync');
+  });
+
+  test('stays quiet when another trail crosses the internal trail in the same file', () => {
+    const code = `
+trail('entity.public', {
+  crosses: ['entity.sync'],
+  blaze: async (_input, ctx) => ctx.cross('entity.sync', {}),
+});
+
+trail('entity.sync', {
+  visibility: 'internal',
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    expect(deadInternalTrail.check(code, TEST_FILE)).toEqual([]);
+  });
+
+  test('stays quiet when project context marks the trail as crossed elsewhere', () => {
+    const code = `
+trail('entity.sync', {
+  visibility: 'internal',
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    const diagnostics = deadInternalTrail.checkWithContext(code, TEST_FILE, {
+      crossTargetTrailIds: new Set(['entity.sync']),
+      knownTrailIds: new Set(['entity.public', 'entity.sync']),
+    });
+
+    expect(diagnostics).toEqual([]);
+  });
+
+  test('stays quiet when the internal trail has on: activation', () => {
+    const code = `
+trail('entity.audit', {
+  visibility: 'internal',
+  on: ['entity.created'],
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    expect(deadInternalTrail.check(code, TEST_FILE)).toEqual([]);
+  });
+
+  test('stays quiet when on: is a module-level identifier reference', () => {
+    const code = `
+const activationSignals = ['entity.created', 'entity.updated'];
+
+trail('entity.audit', {
+  visibility: 'internal',
+  on: activationSignals,
+  blaze: async () => Result.ok({}),
+});
+`;
+
+    expect(deadInternalTrail.check(code, TEST_FILE)).toEqual([]);
+  });
+});

package/src/__tests__/draft-rules-context.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from 'bun:test';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { draftFileMarking } from '../rules/draft-file-marking.js';
+import { draftVisibleDebt } from '../rules/draft-visible-debt.js';
+
+/**
+ * Absolute paths to the two real framework files that define the draft-prefix
+ * constants. The exemption in `collectFrameworkDraftPrefixConstantOffsets` is
+ * keyed on absolute-path equality against these two paths.
+ */
+const CORE_DRAFT_PATH = resolve(
+  fileURLToPath(new URL('../../../core/src/draft.ts', import.meta.url))
+);
+const WARDEN_DRAFT_PATH = resolve(
+  fileURLToPath(new URL('../draft.ts', import.meta.url))
+);
+
+/** Any file outside the two framework files — exemption must NOT apply here. */
+const NORMAL_FILE = 'packages/example/src/ordinary.ts';
+
+describe('draft-file-marking context-awareness', () => {
+  test('ignores framework DRAFT_ID_PREFIX in packages/core/src/draft.ts', () => {
+    const code = `export const DRAFT_ID_PREFIX = '_draft.';\n`;
+    expect(draftFileMarking.check(code, CORE_DRAFT_PATH)).toEqual([]);
+  });
+
+  test('ignores framework DRAFT_FILE_PREFIX in packages/warden/src/draft.ts', () => {
+    const code = `export const DRAFT_FILE_PREFIX = '_draft.';\n`;
+    expect(draftFileMarking.check(code, WARDEN_DRAFT_PATH)).toEqual([]);
+  });
+
+  test('fires when DRAFT_ID_PREFIX is reused in a non-framework file (false-negative closed)', () => {
+    // Before TRL-334 follow-up: identifier-name-only match silently suppressed
+    // this as "framework declaration". After: the path gate rejects the
+    // consumer file and the leak fires.
+    const code = `const DRAFT_ID_PREFIX = '_draft.user-leak';\n`;
+    const diagnostics = draftFileMarking.check(code, NORMAL_FILE);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('error');
+  });
+
+  test('fires when DRAFT_FILE_PREFIX is reused in a non-framework file', () => {
+    const code = `const DRAFT_FILE_PREFIX = '_draft.other-leak';\n`;
+    const diagnostics = draftFileMarking.check(code, NORMAL_FILE);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('error');
+  });
+
+  test('fires when framework file declares the constant with a non-_draft. value (value invariant)', () => {
+    // Same file path, same identifier, but wrong literal — exemption must
+    // require the exact '_draft.' value.
+    const code = `export const DRAFT_ID_PREFIX = '_draft.something-else';\n`;
+    const diagnostics = draftFileMarking.check(code, CORE_DRAFT_PATH);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('error');
+  });
+
+  test('still flags draft ids in arbitrary const declarations', () => {
+    const code = `const something = '_draft.foo';\n`;
+    const diagnostics = draftFileMarking.check(code, NORMAL_FILE);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('error');
+  });
+
+  test('warden-ignore-next-line pragma suppresses diagnostic', () => {
+    const code = `// warden-ignore-next-line\nconst x = '_draft.intentional';\n`;
+    expect(draftFileMarking.check(code, NORMAL_FILE)).toEqual([]);
+  });
+
+  test('pragma with trailing whitespace still suppresses diagnostic', () => {
+    const code = `// warden-ignore-next-line   \nconst x = '_draft.intentional';\n`;
+    expect(draftFileMarking.check(code, NORMAL_FILE)).toEqual([]);
+  });
+
+  test('pragma with blank line between does not suppress', () => {
+    const code = `// warden-ignore-next-line\n\nconst x = '_draft.intentional';\n`;
+    const diagnostics = draftFileMarking.check(code, NORMAL_FILE);
+    expect(diagnostics.length).toBe(1);
+  });
+
+  test('does not falsely flag "marked without ids" when all draft ids are pragma-suppressed', () => {
+    // In a draft-marked file, pragma-suppressed draft ids still justify the
+    // filename marker — the user intentionally silenced them, not removed
+    // them. The "marked without ids" cleanup nudge must not fire.
+    const code = `// warden-ignore-next-line\nconst x = '_draft.intentional';\n`;
+    const diagnostics = draftFileMarking.check(
+      code,
+      'packages/example/src/thing._draft.ts'
+    );
+    expect(diagnostics).toEqual([]);
+  });
+});
+
+describe('draft-visible-debt context-awareness', () => {
+  test('ignores framework DRAFT_ID_PREFIX in packages/core/src/draft.ts', () => {
+    const code = `export const DRAFT_ID_PREFIX = '_draft.';\n`;
+    expect(draftVisibleDebt.check(code, CORE_DRAFT_PATH)).toEqual([]);
+  });
+
+  test('ignores framework DRAFT_FILE_PREFIX in packages/warden/src/draft.ts', () => {
+    const code = `export const DRAFT_FILE_PREFIX = '_draft.';\n`;
+    expect(draftVisibleDebt.check(code, WARDEN_DRAFT_PATH)).toEqual([]);
+  });
+
+  test('fires when DRAFT_ID_PREFIX is reused in a non-framework file (false-negative closed)', () => {
+    const code = `const DRAFT_ID_PREFIX = '_draft.user-leak';\n`;
+    const diagnostics = draftVisibleDebt.check(code, '_draft.something.ts');
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('warn');
+  });
+
+  test('fires when DRAFT_FILE_PREFIX is reused in a non-framework file', () => {
+    const code = `const DRAFT_FILE_PREFIX = '_draft.other-leak';\n`;
+    const diagnostics = draftVisibleDebt.check(code, '_draft.something.ts');
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('warn');
+  });
+
+  test('fires when framework file declares the constant with a non-_draft. value (value invariant)', () => {
+    const code = `export const DRAFT_ID_PREFIX = '_draft.something-else';\n`;
+    const diagnostics = draftVisibleDebt.check(code, CORE_DRAFT_PATH);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('warn');
+  });
+
+  test('still flags draft ids in arbitrary const declarations', () => {
+    const code = `const something = '_draft.foo';\n`;
+    const diagnostics = draftVisibleDebt.check(code, '_draft.something.ts');
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.severity).toBe('warn');
+  });
+
+  test('warden-ignore-next-line pragma suppresses diagnostic', () => {
+    const code = `// warden-ignore-next-line\nconst x = '_draft.intentional';\n`;
+    expect(draftVisibleDebt.check(code, '_draft.something.ts')).toEqual([]);
+  });
+
+  test('pragma with trailing whitespace still suppresses diagnostic', () => {
+    const code = `// warden-ignore-next-line   \nconst x = '_draft.intentional';\n`;
+    expect(draftVisibleDebt.check(code, '_draft.something.ts')).toEqual([]);
+  });
+
+  test('pragma with blank line between does not suppress', () => {
+    const code = `// warden-ignore-next-line\n\nconst x = '_draft.intentional';\n`;
+    const diagnostics = draftVisibleDebt.check(code, '_draft.something.ts');
+    expect(diagnostics.length).toBe(1);
+  });
+});