declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/.test/assets/{expo-fullusecase/declarations/practices/lint-react-native/best-practice → lint/declarations/practices/lint/bad-practices/eslint}/.eslintrc.js

@@ -4,54 +4,64 @@ module.exports = {
     'plugin:@typescript-eslint/recommended', // Uses the recommended rules from the @typescript-eslint/eslint-plugin
     'plugin:import/recommended', // specifies good import rules
     'airbnb-typescript/base', // uses the airbnb recommended rules
-    'plugin:react/recommended',
-    'plugin:react-hooks/recommended',
-    'plugin:jsx-a11y/recommended',
     'plugin:prettier/recommended', // Enables eslint-plugin-prettier and displays prettier errors as ESLint errors. Make sure this is always the last configuration in the extends array.
   ],
+  plugins: ['unused-imports'],
   parserOptions: {
     project: './tsconfig.json',
     ecmaVersion: 2018, // Allows for the parsing of modern ECMAScript features
     sourceType: 'module', // Allows for the use of imports
   },
   rules: {
-    'import/extensions': 'off', // too many false positives; should figure out why
-    'react/react-in-jsx-scope': 'off', // https://stackoverflow.com/a/68315971/3068233
-    'react/no-unescaped-entities': 'off', // too invasive -> not seeing the value either
-    '@typescript-eslint/explicit-function-return-type': 'off', // this can be figured out implicitly, and that is better
+    '@typescript-eslint/explicit-module-boundary-types': 'error', // makes code-reviews easier + code quality better by explicitly defining outputs of exported functions+classes
+    '@typescript-eslint/explicit-function-return-type': 'off', // prefer '@typescript-eslint/explicit-module-boundary-types' since it only requires the check on exported functions+classes
     'sort-imports': 'off',
     'import/prefer-default-export': 'off', // default export = bad
     'import/no-default-export': 'error', // require named exports - they make it easier to refactor, enforce consistency, and increase constraints
-    '@typescript-eslint/no-non-null-assertion': 'off', // we use these to help typescript out when we know something it doesnt, and cant easily express that
+    '@typescript-eslint/no-non-null-assertion': 'error', // forbid non-null assertion operators for safer code; you can always `?? UnexpectedCodePathError.throw(...)` to fail fast instead
     'import/no-extraneous-dependencies': [
       'error',
       {
         devDependencies: [
-          '**/*.test.ts',
+          '!(src)/**/*.ts', // everything outside src/* is a dev only asset
+          '**/*.test.ts', // all explicitly .test files are dev only assets too
           '**/*.test.integration.ts',
           '**/*.test.acceptance.ts',
-          'acceptance/**/*.ts',
-          '**/__test_utils__/**/*.ts',
-          'provision/**/*.ts',
+          '**/.test/**/*.ts',
         ],
       },
     ],
-    '@typescript-eslint/no-explicit-any': 'off', // sometimes this is a valid definition
-    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    '@typescript-eslint/no-explicit-any': 'error', // forbid any type for better type safety; you can use `never` or `unknown` instead when its truly unknown or never needed to be known
+    '@typescript-eslint/consistent-type-imports': [
+      'error',
+      {
+        prefer: 'type-imports', // enforce using `import type` for type-only imports
+        fixStyle: 'inline-type-imports', // use inline `import { type Foo }` style
+        disallowTypeAnnotations: true, // disallow using `import type` in type annotations
+      },
+    ],
+    'no-unused-vars': 'off', // turn off base rule as it can report incorrect errors
+    '@typescript-eslint/no-unused-vars': 'off', // turn off in favor of unused-imports/no-unused-vars
+    'unused-imports/no-unused-imports': 'error', // auto-fixable rule to remove unused imports
+    'unused-imports/no-unused-vars': [
+      'warn',
+      {
+        vars: 'all',
+        varsIgnorePattern: '^_',
+        args: 'after-used',
+        argsIgnorePattern: '^_',
+      },
+    ],
     'import/no-cycle': 'off',
     'max-classes-per-file': 'off',
     '@typescript-eslint/no-use-before-define': 'off',
     '@typescript-eslint/no-floating-promises': 'error',
     'prefer-destructuring': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
     'lines-between-class-members': 'off',
     '@typescript-eslint/lines-between-class-members': 'off',
     'no-return-await': 'off', // this does not help anything and actually leads to bugs if we subsequently wrap the return in a try catch without remembering to _then_ add await
     '@typescript-eslint/return-await': 'off',
-    '@typescript-eslint/no-unsafe-declaration-merging': 'off',
+    '@typescript-eslint/no-unsafe-declaration-merging': 'off', // dobjs are built off of this
     '@typescript-eslint/default-param-last': 'off', // interferes with input vs context
   },
-  settings: {
-    'import/ignore': ['react-native'], // https://github.com/facebook/react-native/issues/28549
-  },
 };

package/dist/.test/assets/lint/declarations/practices/lint/bad-practices/eslint/package.json.declapract.ts

@@ -0,0 +1,51 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+const depsBlocklist = [
+  '@typescript-eslint/eslint-plugin',
+  '@typescript-eslint/parser',
+  'eslint',
+  'eslint-config-airbnb-typescript',
+  'eslint-config-prettier',
+  'eslint-plugin-import',
+  'eslint-plugin-prettier',
+  'eslint-plugin-unused-imports',
+];
+
+const scriptsBlocklist = ['test:lint:eslint'];
+
+export const check: FileCheckFunction = (contents) => {
+  if (!contents) throw Error('does not match bad practice');
+  const packageJSONObject = JSON.parse(contents);
+  const devDepsFound = Object.keys(packageJSONObject.devDependencies ?? {});
+  const scriptsFound = Object.keys(packageJSONObject.scripts ?? {});
+  if (
+    depsBlocklist.some((dep) => devDepsFound.includes(dep)) ||
+    scriptsBlocklist.some((script) => scriptsFound.includes(script))
+  )
+    return; // matches bad practice
+  throw new Error('does not match bad practice');
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {}; // should not occur
+  const packageJSONObject = JSON.parse(contents);
+
+  // Remove blocklisted devDependencies
+  const updatedDevDeps = { ...packageJSONObject.devDependencies };
+  for (const dep of depsBlocklist) {
+    delete updatedDevDeps[dep];
+  }
+
+  // Remove blocklisted scripts
+  const updatedScripts = { ...packageJSONObject.scripts };
+  for (const script of scriptsBlocklist) {
+    delete updatedScripts[script];
+  }
+
+  const fixedPackageJSONObject = {
+    ...packageJSONObject,
+    devDependencies: updatedDevDeps,
+    scripts: packageJSONObject.scripts ? updatedScripts : undefined,
+  };
+  return { contents: JSON.stringify(fixedPackageJSONObject, null, 2) };
+};

package/dist/.test/assets/lint/declarations/practices/lint/bad-practices/tslint/package.json.declapract.ts

@@ -0,0 +1,22 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+export const check: FileCheckFunction = (contents) => {
+  const packageJSONObject = JSON.parse(contents!);
+  if (Object.keys(packageJSONObject.dependencies).includes('uuidv4')) return; // matches
+  throw new Error('does not match bad practice');
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {}; // should not occur
+  const packageJSONObject = JSON.parse(contents);
+  const fixedPackageJSONObject = {
+    ...packageJSONObject,
+    dependencies: {
+      ...packageJSONObject.dependencies,
+      tslint: undefined,
+      'tslint-config-airbnb': undefined,
+      'tslint-consistent-codestyle': undefined,
+    },
+  };
+  return { contents: JSON.stringify(fixedPackageJSONObject, null, 2) };
+};

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/.declapract.readme.md

@@ -0,0 +1,5 @@
+# biome
+prevents bad practices and improves code quality
+
+# depcheck
+helps prune unneeded packages to minimize security-risk surface area

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/.depcheckrc.yml

@@ -0,0 +1,39 @@
+ignores:
+  - "@src/*"
+  - "@src/.*"
+  # all rhachet packages (roles/brains churn as prepare:rhachet installs vary)
+  - "rhachet*"
+  # runtime deps of the ghlitch operator use.vpc.tunnel skill (installed under
+  # .agent/repo=ghlitch via prepare:rhachet); no committed src imports them, so
+  # depcheck cannot attribute them in the ci lint job where the skill is absent
+  - declastruct-aws
+  - declastruct-unix-network
+  - declapract
+  - declapract-typescript-ehmpathy
+  - "@commitlint/config-conventional"
+  - "@tsconfig/node20"
+  - "@tsconfig/strictest"
+  - "@biomejs/biome"
+  - esbuild-register
+  - "@swc/core"
+  - "@swc/jest"
+  - husky
+  - tsx
+  - tsc-alias
+  - yalc
+  - test-fns
+  - type-fns
+  # read by the test:lint:cycles command via `node -p "require('yaml')..."`; depcheck does not
+  # parse npm commands, so it cannot attribute the require
+  - yaml
+ignorePatterns:
+  # rhachet host-local runtime state (actor caches, plugin copies); gitignored,
+  # never source, and its files import packages this repo does not use
+  - .agent/.actors
+  # rhachet links `.claude` into the enrolled actor's dir, so depcheck reaches the same
+  # host-local cache through it; the link is not source either
+  - .claude
+  # role dirs vendored from other repos import their own origin's deps; only
+  # this repo's own role dir is source that depcheck should attribute
+  - .agent/repo=*
+  - "!.agent/repo=.this"

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/.depcheckrc.yml.declapract.ts

@@ -0,0 +1,174 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type {
+  FileCheckFunction,
+  FileContentsFunction,
+  FileFixFunction,
+} from 'declapract';
+import { readFile } from 'fs/promises';
+import { ConstraintError, MalfunctionError } from 'helpful-errors';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import yaml from 'yaml';
+
+import path from 'node:path';
+import { isJsonObject } from '../../../utils/asJsonMergedDeep';
+
+/**
+ * .what = the seq keys of `.depcheckrc.yml` this practice declares and merges
+ * .why  = each is a list of entries a repo may extend with its own; the practice only
+ *         guarantees the presence of its declared entries, never their order or exclusivity
+ */
+const MERGED_SEQ_KEYS = ['ignores', 'ignorePatterns'] as const;
+type MergedSeqKey = (typeof MERGED_SEQ_KEYS)[number];
+
+/**
+ * .what = the ignores an expo repo adds atop the base list
+ * .why  = expo owns the bundled metro, so a consumer pins no `metro-config`; a require of it
+ *         from `metro.config.js` reads to depcheck as an undeclared dep (#609). a union, so a
+ *         narrow `--practice lint` apply (where the expo signal goes dark) strips no line
+ */
+const IGNORES_EXPO = ['metro-config'];
+
+/**
+ * .what = reads the declared seq entries for a key from a parsed `.depcheckrc.yml`
+ * .why  = one shape for check + fix, so the gate and the repair agree
+ */
+const getSeqEntries = (input: {
+  parsed: unknown;
+  key: MergedSeqKey;
+}): string[] => {
+  const value = isJsonObject(input.parsed)
+    ? input.parsed[input.key]
+    : undefined;
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : [];
+};
+
+/**
+ * .what = the seq node a `.depcheckrc.yml` key holds; halts loud where the key holds no list
+ * .why  = an entry can only be added to a list; a scalar or map under the key is a file the merge
+ *         cannot repair, so it names the key rather than throw a bare TypeError on `.add`
+ */
+const asSeqNode = (input: { node: unknown; key: string }): yaml.YAMLSeq => {
+  if (!yaml.isSeq(input.node))
+    throw new ConstraintError(
+      `.depcheckrc.yml \`${input.key}\` is not a list`,
+      {
+        key: input.key,
+        hint: `make \`${input.key}\` a yaml list, then run \`declapract apply\` again`,
+      },
+    );
+  return input.node;
+};
+
+/**
+ * .what = the parsed declared `.depcheckrc.yml`; halts loud when declapract emitted none
+ * .why  = an absent declared side parses to no entries, which would let the check approve any
+ *         file; a declared template is always emitted for this best-practice, so its absence is a
+ *         malfunction to name, never a silent pass
+ */
+const asDeclaredParsed = (input: {
+  declaredFileContents: string | null;
+  relativeFilePath: string;
+}): unknown => {
+  if (input.declaredFileContents === null)
+    throw new MalfunctionError(
+      'the lint practice emitted no declared .depcheckrc.yml',
+      { relativeFilePath: input.relativeFilePath },
+    );
+  return yaml.parse(input.declaredFileContents);
+};
+
+/**
+ * .what = the declared `.depcheckrc.yml`, usecase-aware for the expo runtime
+ * .why  = an expo repo needs `metro-config` ignored; every other repo gets the base template
+ */
+export const contents: FileContentsFunction = async (context) => {
+  const base = await readFile(path.join(__dirname, '.depcheckrc.yml'), 'utf-8');
+  if (!context.projectPractices.includes('tests-expo')) return base;
+
+  // union the expo ignores into the base, comments kept
+  const doc = yaml.parseDocument(base);
+  const ignoresNode = asSeqNode({ node: doc.get('ignores'), key: 'ignores' });
+  IGNORES_EXPO.forEach((ignore) => ignoresNode.add(ignore)); // .note = deliberate mutation — yaml doc api
+  return doc.toString();
+};
+
+/**
+ * .what = the declared entries of one seq key that the found file lacks
+ */
+const getAllEntriesAbsent = (input: {
+  declared: unknown;
+  found: unknown;
+  key: MergedSeqKey;
+}): string[] => {
+  const entriesFound = getSeqEntries({ parsed: input.found, key: input.key });
+  return getSeqEntries({ parsed: input.declared, key: input.key }).filter(
+    (entry) => !entriesFound.includes(entry),
+  );
+};
+
+/**
+ * .what = throws when a declared `ignores` or `ignorePatterns` entry is absent
+ * .why  = a findsert gate: the repo may hold its own entries in any order, so the check
+ *         mandates the PRESENCE of each declared entry, never textual equality — which
+ *         also makes `check(fix(x))` pass (a plain-text CONTAINS never could, once a repo
+ *         holds its own entries)
+ * .note = best-practice semantics: throw = violated, return = followed
+ */
+export const check: FileCheckFunction = (contents, context) => {
+  if (!contents)
+    throw new ConstraintError('.depcheckrc.yml is absent', {
+      relativeFilePath: context.relativeFilePath,
+    });
+  const found = yaml.parse(contents);
+  const declared = asDeclaredParsed(context);
+  const absent = MERGED_SEQ_KEYS.flatMap((key) =>
+    getAllEntriesAbsent({ declared, found, key }).map(
+      (entry) => `${key}: ${entry}`,
+    ),
+  );
+  if (absent.length)
+    throw new ConstraintError(
+      '.depcheckrc.yml lacks declared entries; run `declapract apply` to merge them',
+      { absent },
+    );
+};
+
+/**
+ * .what = merges each declared `ignores` + `ignorePatterns` entry into the extant file
+ * .why  = a CONTAINS template alone never reaches an extant file (#639); the merge seeds a
+ *         seq if absent, adds each absent entry, and keeps the repo's own entries + comments
+ * .note = a fixed point: a present entry is never added twice, so fix(fix(x)) === fix(x)
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  if (!contents) return { contents: context.declaredFileContents };
+
+  // parse both files (parseDocument keeps comments)
+  const currentDoc = yaml.parseDocument(contents);
+  const currentParsed = currentDoc.toJSON();
+  const declaredParsed = asDeclaredParsed(context);
+
+  // merge each seq key
+  const changed = MERGED_SEQ_KEYS.map((key) => {
+    const absentEntries = getAllEntriesAbsent({
+      declared: declaredParsed,
+      found: currentParsed,
+      key,
+    });
+    if (!absentEntries.length) return false;
+
+    // get the seq node; seed an empty seq onto the doc if absent
+    if (!currentDoc.get(key)) currentDoc.set(key, currentDoc.createNode([]));
+    const seqNode = asSeqNode({ node: currentDoc.get(key), key });
+
+    // add each absent declared entry to the repo's own list
+    // .note = deliberate mutation — the yaml document api mutates the seq node in
+    // place to keep the comments around it; there is no immutable seq-add
+    absentEntries.forEach((entry) => seqNode.add(entry));
+    return true;
+  });
+
+  if (!changed.some(Boolean)) return { contents };
+  return { contents: currentDoc.toString() };
+};

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/.dpdmrc.yaml

@@ -0,0 +1,17 @@
+# dpdm exclude patterns — each entry is joined with | into a single --exclude regex.
+#
+# an empty `exclude: []` means dpdm checks every file for cycles, node_modules included. this is
+# the org policy `rule.forbid.dpdm-exclude-change`: we check dependencies too, because a prod-dep
+# cycle ships to consumers.
+#
+# when an entry is allowed:
+# - a type-only cycle: never. --transform erases type imports before analysis, so none is owed
+# - a test file: never. the '!(*.test).ts' glob already drops test files
+# - a require cycle inside a third-party devDependency: allowed, one entry per package, each with
+#   a comment that cites the cycle and the upstream issue
+# - a require cycle inside a prod dependency: never. it ships to consumers — dispatch the fix
+#   upstream or replace the dependency
+#
+# an entry of `node_modules` (or dpdm's own `/node_modules/` default) disables the check across
+# every consumer repo, and the declapract check rejects it.
+exclude: []

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/.dpdmrc.yaml.declapract.ts

@@ -0,0 +1,82 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import { ConstraintError } from 'helpful-errors';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import yaml from 'yaml';
+
+/**
+ * .what = whether one exclude entry would hide node_modules from dpdm
+ * .why  = node_modules in scope IS the policy (`rule.forbid.dpdm-exclude-change`); an entry that
+ *         names it disables the cycle check across the whole dependency tree
+ */
+const isNodeModulesEntry = (input: { entry: unknown }): boolean =>
+  String(input.entry).includes('node_modules');
+
+/**
+ * .what = the `.dpdmrc.yaml` policy holds: `exclude` is a list, and no entry names node_modules
+ * .why  = the file was EQUALS, so every apply deleted the cited devDep entries the policy itself
+ *         allows (#628). this check passes any policy-valid list, so an adopter's entry survives.
+ * .note = best-practice semantics: throw = violated, return = followed
+ */
+export const check: FileCheckFunction = (contents, context) => {
+  if (!contents)
+    throw new ConstraintError('.dpdmrc.yaml is absent', {
+      relativeFilePath: context.relativeFilePath,
+    });
+  const exclude: unknown = yaml.parse(contents)?.exclude;
+  if (!Array.isArray(exclude))
+    throw new ConstraintError('.dpdmrc.yaml `exclude` is not a list', {
+      exclude,
+    });
+  const offenders = exclude.filter((entry) => isNodeModulesEntry({ entry }));
+  if (offenders.length)
+    throw new ConstraintError(
+      '.dpdmrc.yaml `exclude` names node_modules, which disables the cycle check on dependencies',
+      { offenders },
+    );
+};
+
+/**
+ * .what = write the declared file when absent; otherwise repair only the policy breach
+ * .why  = a check with no usable fix makes declapract mark the whole file manual (#607), so the
+ *         fix must turn every red the check can raise into green: it seeds `exclude: []` when the
+ *         key is absent or not a list, and drops only the node_modules entries. the adopter's other
+ *         entries and comments survive.
+ * .note = a fixed point: on a policy-valid file it returns the contents unchanged
+ */
+export const fix: FileFixFunction = (contents, context) => {
+  if (!contents) return { contents: context.declaredFileContents };
+
+  // parse with comments kept
+  const doc = yaml.parseDocument(contents);
+
+  // a root that does not parse, or is not a map, holds no policy to keep; write the declared file
+  if (doc.errors.length || (doc.contents !== null && !yaml.isMap(doc.contents)))
+    return { contents: context.declaredFileContents };
+  const exclude: unknown = doc.toJSON()?.exclude;
+
+  // seed an empty list when the key is absent or not a list
+  if (!Array.isArray(exclude)) {
+    doc.set('exclude', doc.createNode([]));
+    return { contents: doc.toString() };
+  }
+
+  // drop only the node_modules entries from the repo's own list, judged by each item's resolved value (an alias or a
+  // non-scalar resolves exactly as the check reads it), aligned to the seq by index
+  if (!exclude.some((entry) => isNodeModulesEntry({ entry })))
+    return { contents };
+  const seq = doc.get('exclude');
+
+  // an alias to a list holds no items in place; set the kept values as a fresh list
+  if (!yaml.isSeq(seq)) {
+    doc.set(
+      'exclude',
+      doc.createNode(exclude.filter((entry) => !isNodeModulesEntry({ entry }))),
+    );
+    return { contents: doc.toString() };
+  }
+  seq.items = seq.items.filter(
+    (_item, index) => !isNodeModulesEntry({ entry: exclude[index] }),
+  ); // .note = deliberate mutation — the yaml document api keeps comments only in place
+  return { contents: doc.toString() };
+};

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/biome.jsonc

@@ -0,0 +1,106 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.3.8/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "includes": [
+      "**/src/**/*.ts",
+      "**/provision/**/*.ts",
+      "**/blackbox/**/*.ts",
+      "!**/dist",
+      "!**/coverage",
+      "!**/node_modules",
+      "!**/.agent/.cache",
+      "!**/.artifact",
+      "!**/.generated",
+      "!**/.test*"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 80
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "trailingCommas": "all"
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": {
+          "level": "on",
+          "options": {
+            "groups": [
+              ":SIDE_EFFECT:",
+              ":BLANK_LINE:",
+              [":PACKAGE:", "!@src", "!@src/**"],
+              ":BLANK_LINE:",
+              ["@src", "@src/**"],
+              ":BLANK_LINE:",
+              ":RELATIVE:"
+            ]
+          }
+        }
+      }
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "complexity": {
+        "noExcessiveCognitiveComplexity": "warn",
+        "noThisInStatic": {
+          "level": "warn", // warn w/o autofix, since some usecases like polymorphism require `this` in static methods
+          "fix": "none"
+        }
+      },
+      "correctness": {
+        "noUnusedImports": {
+          "level": "error",
+          "fix": "safe"
+        },
+        "noUnusedVariables": "warn",
+        "useExhaustiveDependencies": "off"
+      },
+      "style": {
+        "noDefaultExport": "error",
+        "noNonNullAssertion": {
+          "level": "warn",
+          "fix": "none"
+        },
+        "useImportType": "error",
+        "noParameterAssign": "off",
+        "noRestrictedImports": {
+          "level": "error",
+          "options": {
+            "paths": {
+              "simple-lambda-testing-methods": "use runLambdaEndpoint from sdk-aws-lambda — .onReferenced in integration tests, .onSerialized in acceptance tests"
+            }
+          }
+        }
+      },
+      "suspicious": {
+        "noExplicitAny": "warn",
+        "noConfusingVoidType": "off",
+        "noEmptyBlockStatements": "off",
+        "noUnsafeDeclarationMerging": "off",
+        "useIterableCallbackReturn": "warn",
+        "noDuplicateTestHooks": "off",
+        "noThenProperty": "warn",
+        "noFocusedTests": "error"
+      },
+      "nursery": {
+        "noFloatingPromises": "error",
+        "useExplicitType": "warn"
+      }
+    }
+  }
+}

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/package.json

@@ -0,0 +1,18 @@
+{
+  "devDependencies": {
+    "depcheck": "1.4.3",
+    "dpdm": "4.0.1",
+    "@biomejs/biome": "2.3.8",
+    "yaml": "2.9.1"
+  },
+  "scripts": {
+    "fix:format:biome": "biome check --write",
+    "fix:lint": "biome check --write",
+    "test:format:biome": "biome format",
+    "test:lint:biome": "biome check --diagnostic-level=error",
+    "test:lint:biome:all": "biome check",
+    "test:lint:cycles": "EXCL=$(node -p \"(require('yaml').parse(require('fs').readFileSync('.dpdmrc.yaml','utf8'))?.exclude ?? []).join('|')\") && dpdm --no-warning --no-tree --transform --exit-code circular:1 --exclude \"$EXCL\" 'src/**/!(*.test).ts'",
+    "test:lint:deps": "depcheck -c ./.depcheckrc.yml",
+    "test:lint": "npm run test:lint:biome && npm run test:lint:cycles && npm run test:lint:deps"
+  }
+}

package/dist/.test/assets/lint/declarations/practices/lint/best-practice/package.json.declapract.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;