@noctcore/lint-meta-rules 0.1.0

package/docs/rules/agents-doc-presence.md

@@ -0,0 +1,40 @@
+# `agents-doc-presence`
+
+> An agent-contract doc must exist at the repo root, every surface, and every non-opted-out package.
+
+## Why
+
+An agent editing a boundary should read its guardrails first. Requiring an `AGENTS.md` (or whatever
+doc you name) at the root and at every meaningful package means the contract is never missing where it
+matters. A new package ships the doc by default; only trivial leaves opt out, and the opt-out is
+explicit and reviewable.
+
+## What it flags
+
+Reports a missing doc at:
+
+- the repo root (unless `requireAtRoot` is `false`),
+- every directory derived from `surfaceGlobs` (all surfaces), and
+- every directory derived from `packageGlobs`, except those in `optOut`.
+
+## Factory
+
+```ts
+createAgentsDocPresenceRule(options?: AgentsDocPresenceOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `docFile` | `string` | `'AGENTS.md'` | The agent-contract filename required in each location. |
+| `requireAtRoot` | `boolean` | `true` | Whether the repo root must carry the doc. |
+| `surfaceGlobs` | `string[]` | `['apps/*/package.json']` | Surfaces (all require the doc). |
+| `packageGlobs` | `string[]` | `['packages/*/package.json']` | Library packages (require the doc unless opted out). |
+| `optOut` | `string[]` | `[]` | Package directories exempt from the requirement. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `AGENTS.md`, the root/apps/packages layout and a fixed
+leaf opt-out set.
+
+## When not to use it
+
+If your repo does not adopt an agent-contract doc convention, skip it.

package/docs/rules/canonical-helpers-single-home.md

@@ -0,0 +1,35 @@
+# `canonical-helpers-single-home`
+
+> A helper symbol must not be exported from two different helper homes.
+
+## Why
+
+When the same helper name is exported from multiple files, callers import inconsistent copies and the
+implementations drift. Keeping each helper in one canonical home makes "where does `slug` live?"
+unambiguous and prevents silent divergence.
+
+## What it flags
+
+Scans the files matched by `include` (minus any path containing an `excludeContains` fragment),
+extracts top-level exported identifiers (from `export function|const|let|var …` and `export { … }`
+lists — keyed on the **local** name before any `as`), and flags any name that appears as an export in
+more than one file. Strict, no baseline.
+
+## Factory
+
+```ts
+createCanonicalHelpersSingleHomeRule(options?: CanonicalHelpersSingleHomeOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `include` | `string[]` | `['apps/web/src/**/*.utils.ts']` | Helper-home files to scan for duplicate exports. |
+| `excludeContains` | `string[]` | `['/lib/']` | Drop any matched path containing one of these fragments. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `apps/web/src/**/*.utils.ts` and a `/lib/` exclusion.
+
+## When not to use it
+
+If your project intentionally re-exports the same symbol from several modules (barrels, façades), scope
+`include` to just the canonical-home files or skip the rule.

package/docs/rules/file-size-ratchet.md

@@ -0,0 +1,72 @@
+# `file-size-ratchet`
+
+> Source files stay at or under a line cap, with a one-way, self-tightening baseline ratchet.
+
+This single factory subsumes **both** of nightcore's file-size rules — `web-file-size-ratchet`
+(apps/web/src, `.ts`+`.tsx`) and `engine-file-size-ratchet` (packages/engine/src, `.ts`) — which were
+byte-identical logic differing only in scanned roots, extensions and exclusions. Create one instance
+per capped area, each with its own `id` (the `id` names both the rule and its committed baseline file).
+
+## Why
+
+Nothing else caps whole-file size, and per-file escape hatches (e.g. ESLint counting only *exported*
+hooks) let mega-files slip through. A ratchet freezes today's offenders and forbids growth: legacy
+files may only shrink, and new files may never join. It does not force a refactor now — it stops the
+debt from growing, and captures paydowns as they happen.
+
+## What it flags
+
+Measured in raw physical lines (`wc -l` semantics). Against a committed baseline at
+`<baselineDir>/<id>.json`:
+
+- a **new** over-cap file (not in the baseline), or a baselined one that **grew** past its frozen
+  count — a live violation;
+- a baselined file still within its frozen count — **grandfathered** (a stderr notice, no violation);
+- **self-tightening**: a baseline entry whose file is gone, is now at/under the cap, or shrank far
+  below its frozen value (`< frozen * tightenRatio`) is itself a violation demanding a baseline update.
+
+The rule implements `baseline(ctx)` (the `IMetaRule` ratchet hook), which snapshots the current
+offender map so the runner can regenerate the frozen file.
+
+## Factory
+
+```ts
+createFileSizeRatchetRule(options?: FileSizeRatchetOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `id` | `string` | `'file-size-ratchet'` | Rule id **and** baseline file basename — give each instance a distinct id. |
+| `roots` | `string[]` | `[]` | Source roots to scan (**empty is inert**), e.g. `['apps/web/src']`. |
+| `extensions` | `string[]` | `['.ts', '.tsx']` | File extensions to include. |
+| `cap` | `number` | `400` | The per-file line cap. |
+| `excludeContains` | `string[]` | `['.test.', '.spec.', '.stories.']` | Exclude paths containing any of these. |
+| `excludePrefixes` | `string[]` | `[]` | Exclude paths starting with any of these (e.g. codegen dirs). |
+| `tightenRatio` | `number` | `0.85` | A baseline entry below `frozen * ratio` must be re-frozen. |
+| `baselineDir` | `string` | `.nightcore/lint-meta/baselines` | Where committed baselines live (from `@noctcore/harness`). |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+### Example: the two nightcore instances
+
+```ts
+createFileSizeRatchetRule({
+  id: 'web-file-size-ratchet',
+  roots: ['apps/web/src'],
+  extensions: ['.ts', '.tsx'],
+  excludeContains: ['.test.', '.stories.', '__screenshots__'],
+  excludePrefixes: ['apps/web/src/lib/generated/'],
+});
+
+createFileSizeRatchetRule({
+  id: 'engine-file-size-ratchet',
+  roots: ['packages/engine/src'],
+  extensions: ['.ts'],
+});
+```
+
+De-projected from nightcore, which hardcoded the roots, extensions, exclusions and the `400` cap.
+
+## When not to use it
+
+If you have no over-cap files and no desire to cap file size, skip it. If you want a hard cap with no
+grandfathering, commit an empty baseline — every over-cap file then fails immediately.

package/docs/rules/layer-rank.md

@@ -0,0 +1,44 @@
+# `layer-rank`
+
+> A module may import only strictly-lower-ranked `<scope>` packages — equal (sideways) or higher
+> (upward) is forbidden.
+
+## Why
+
+Layered architectures encode a fixed dependency direction (e.g. `contracts → shared → storage/skills
+→ engine → surfaces`). Enforcing it mechanically keeps the spine acyclic: a low tier can never reach
+up into a higher one, and co-tier packages never entangle. New edges that would violate the direction
+are caught before they calcify.
+
+## What it flags
+
+Each source file is assigned an **importer rank**: surface files (matched by `surfacePrefix`) get
+`surfaceRank`; otherwise the `packageDirPattern` capture is looked up in `ranks`. For each
+`<scope>/<pkg>` import whose target is also ranked, the rule flags it when the target rank is `>=` the
+importer rank (sideways when equal, upward when greater). Unranked importers and unranked targets are
+skipped, so a package outside the documented spine never produces a false positive. Test files are
+skipped.
+
+## Factory
+
+```ts
+createLayerRankRule(options?: LayerRankOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `scope` | `string` | `'@nightcore'` | npm scope of workspace packages. |
+| `ranks` | `Record<string,number>` | `{}` | Layer package name → rank. **Empty makes the rule inert** (opt-in). |
+| `surfacePrefix` | `string` | `'apps/'` | Path prefix marking a deployable surface. |
+| `surfaceRank` | `number` | `undefined` | Rank for surface files; omit to leave surfaces unranked. |
+| `packageDirPattern` | `string` | `'^packages/([^/]+)/'` | Regex source extracting the layer name from a file path. |
+| `sourceGlobs` | `string[]` | packages + apps `src/**` `.ts`/`.tsx` | Source files to scan. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded a fixed rank table and the `@nightcore` scope. `ranks`
+defaults to `{}` so the rule is inert until a consumer supplies its own layering.
+
+## When not to use it
+
+If your codebase is not organized into ranked layers, leave `ranks` empty (the rule then does
+nothing).

package/docs/rules/no-cloned-component-folders.md

@@ -0,0 +1,40 @@
+# `no-cloned-component-folders`
+
+> A component folder name may exist under only one feature.
+
+## Why
+
+Same-named component folders across features are how sibling drift starts: a component cloned into a
+second feature diverges silently until the two are subtly incompatible. A genuinely shared surface
+belongs in a shared destination (e.g. `components/ui`); a genuinely different one deserves a name that
+says so.
+
+## What it flags
+
+A `<feature>/<Name>/<barrelFile>` path marks a component folder. Grouping by `<Name>` across features
+(excluding `excludedFeatures`), any name appearing under two or more features — and not in
+`allowedClones` — is flagged. The allowlist freezes today's clone groups and only shrinks: an
+`allowedClones` entry whose clone group no longer exists is itself flagged as stale.
+
+## Factory
+
+```ts
+createNoClonedComponentFoldersRule(options?: NoClonedComponentFoldersOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `componentsRoot` | `string` | `'apps/web/src/components'` | Root under which `<feature>/<Component>/` folders live. |
+| `barrelFile` | `string` | `'index.ts'` | Barrel file that marks a component folder. |
+| `excludedFeatures` | `string[]` | `['ui', 'app']` | Feature folders whose contents are not feature components. |
+| `allowedClones` | `string[]` | `[]` | Component names allowed to be cloned (a shrinking allowlist). |
+| `sharedDest` | `string` | `'components/ui'` | Where a shared surface should be hoisted (used in the message). |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `apps/web/src/components`, the `ui`/`app` excluded
+features, and a fixed `ALLOWED_CLONES` set.
+
+## When not to use it
+
+If your components are not organized as `<feature>/<Component>/` folders under one root, or you
+intentionally maintain per-feature variants, retune or skip the rule.

package/docs/rules/no-warn-severity.md

@@ -0,0 +1,34 @@
+# `no-warn-severity`
+
+> ESLint severity is `error` or `off`, never `warn`.
+
+## Why
+
+Agents iterate by reading CI failures. A `warn` severity is a silent miss — it neither fails the
+build nor gets acted on — so a rule that matters must be an `error`, and a rule that does not should
+be `off`. There is no useful middle.
+
+## What it flags
+
+Reads each configured flat-config file (skipping any that do not exist), strips line comments, and
+reports any line containing a `'warn'` / `"warn"` severity literal. The violation carries the
+1-indexed line number.
+
+## Factory
+
+```ts
+createNoWarnSeverityRule(options?: NoWarnSeverityOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `configFiles` | `string[]` | `['eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs']` | Flat-config files to scan; each is read only if present. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `eslint.config.mjs`.
+
+## When not to use it
+
+If your project deliberately uses `warn` as an in-editor nudge that is not meant to gate CI, this rule
+does not fit — though the recommended pattern is a separate lint layer for gating and `off` for
+everything else.

package/docs/rules/package-shape.md

@@ -0,0 +1,49 @@
+# `package-shape`
+
+> Every workspace is named `<scope>/<dir>`; library packages expose a barrel and point their build
+> fields at the built output.
+
+## Why
+
+A monorepo stays navigable when a package's identity is mechanical: its npm name matches its folder,
+and a library's public surface is a single barrel whose published entrypoints resolve to built output
+rather than raw source. This makes "where does `@scope/foo` live?" and "what does it export?"
+answerable without reading the file.
+
+## What it flags
+
+For each `package.json` matched by `libraryGlobs` (full checks) or `appGlobs` (name check only):
+
+- **name** — must equal `<scope>/<dir-basename>` (or an `externalNames` override).
+- **barrel** (library only) — the package must expose the configured `barrelPath`.
+- **build fields** (library only) — each of `distFields` present as a string must contain
+  `distMarker`, and `exports` must reference it.
+- **invalid JSON** — reported as a violation.
+
+App/surface packages are deployable entrypoints (vite/tauri/bun), so only the name check applies to
+them.
+
+## Factory
+
+```ts
+createPackageShapeRule(options?: PackageShapeOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `scope` | `string` | `'@nightcore'` | npm scope every workspace is named under. |
+| `libraryGlobs` | `string[]` | `['packages/*/package.json']` | Library packages (full checks). |
+| `appGlobs` | `string[]` | `['apps/*/package.json']` | App/surface packages (name check only). |
+| `externalNames` | `Record<string,string>` | `{}` | Directory → exact name overrides for intentionally off-scope packages. |
+| `barrelPath` | `string` | `'src/index.ts'` | Barrel each library must expose, relative to its dir. |
+| `distMarker` | `string` | `'dist/'` | Substring the build-output fields must contain. |
+| `distFields` | `string[]` | `['main','module','types']` | `package.json` string fields that must point at built output. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded the `@nightcore` scope, the `packages/*` vs `apps/*`
+split, the `src/index.ts` barrel and the `dist/` marker.
+
+## When not to use it
+
+If your packages are not scope-named after their folders, or libraries publish raw source (no build
+step), tune or disable the relevant checks via options.

package/docs/rules/test-runner-segregation.md

@@ -0,0 +1,40 @@
+# `test-runner-segregation`
+
+> Bun-side and foreign-side test runners are never mixed within a package.
+
+## Why
+
+A package that mixes two test runners (e.g. `bun:test` and Vitest) has tests that run under one
+command but not another — a coverage gap hiding in plain sight. Segregating the runner by workspace,
+and enforcing it per test file, keeps every test attributable to exactly one runner.
+
+## What it flags
+
+Directories split into a **bun set** (from `bunPackageGlobs` minus `vitestDirs`, plus `bunExtraDirs`)
+and the **foreign set** (`vitestDirs`). For every `*.test.ts(x)` file:
+
+- **bun-side** — must import the bun runner (`bunRunnerImport`) and must NOT import the foreign runner
+  (`foreignRunnerImport`);
+- **foreign-side** — must NOT import the bun runner. (A direct foreign-runner import is not required —
+  it may arrive transitively via shared test-utils.)
+
+## Factory
+
+```ts
+createTestRunnerSegregationRule(options?: TestRunnerSegregationOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `bunPackageGlobs` | `string[]` | `['packages/*/package.json']` | Packages whose dirs default to the bun runner. |
+| `bunExtraDirs` | `string[]` | `[]` | Extra bun-runner directories. |
+| `vitestDirs` | `string[]` | `[]` | Directories that use the foreign (non-bun) runner. |
+| `bunRunnerImport` | `string` | `'bun:test'` | The bun-side runner import specifier. |
+| `foreignRunnerImport` | `string` | `'vitest'` | The foreign runner import specifier. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `bun:test` vs `vitest` and the two dir sets.
+
+## When not to use it
+
+If your repo uses a single test runner everywhere, this rule has nothing to segregate.

package/docs/rules/test-sibling-enforcement.md

@@ -0,0 +1,35 @@
+# `test-sibling-enforcement`
+
+> Every source file matched by `include` must have a colocated sibling test.
+
+## Why
+
+A pure helper with no test is a silent liability — the kind of code that drifts because nothing pins
+its behavior. Requiring a colocated test for a chosen class of files (nightcore's `.utils.ts` sidecars)
+makes "did you test this?" a mechanical check rather than a review-time hope.
+
+## What it flags
+
+For each file matched by an `include` glob, the sibling test is the same path with its `.ts`/`.tsx`
+extension replaced by each configured test extension. If none of those siblings exists, the source
+file is flagged. Strict — there is no baseline; the pattern is opt-in via which files `include` selects.
+
+## Factory
+
+```ts
+createTestSiblingEnforcementRule(options?: TestSiblingEnforcementOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `include` | `string[]` | `['apps/web/src/**/*.utils.ts']` | Source files that must ship a colocated test. |
+| `testExtensions` | `string[]` | `['.test.ts', '.test.tsx']` | Accepted colocated-test extensions (replace the source extension). |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `apps/web/src/**/*.utils.ts` and the `.utils.test.ts(x)`
+sibling shape.
+
+## When not to use it
+
+If you colocate tests loosely or centralize them in a `__tests__` tree, retune `include`/`testExtensions`
+or skip the rule.

package/docs/rules/test-workspace-enrollment.md

@@ -0,0 +1,41 @@
+# `test-workspace-enrollment`
+
+> Every tested package must be enumerated in the aggregate test script.
+
+## Why
+
+When the CI test command is a hardcoded list of workspace paths, a package added without editing that
+list runs in **no gate** — its tests exist but never execute. This rule fails when any candidate
+package that actually has test files is missing from the aggregate script, so a new tested workspace
+cannot silently escape CI.
+
+## What it flags
+
+Reads the root manifest's `scriptName` command. For each candidate directory (from `packageGlobs`
+plus `extraDirs`, minus `excludeDirs`) that contains at least one file matching `testGlobSuffix`, if
+the directory string does not appear in the script command, it is flagged. A missing or invalid
+manifest is a no-op.
+
+## Factory
+
+```ts
+createTestWorkspaceEnrollmentRule(options?: TestWorkspaceEnrollmentOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `scriptName` | `string` | `'test:node'` | Root-manifest script that must enumerate every tested package. |
+| `manifestPath` | `string` | `'package.json'` | The root manifest path. |
+| `packageGlobs` | `string[]` | `['packages/*/package.json']` | Candidate test workspaces. |
+| `extraDirs` | `string[]` | `[]` | Extra directories to check beyond the globbed packages. |
+| `excludeDirs` | `string[]` | `[]` | Directories tested by a different runner/script. |
+| `testGlobSuffix` | `string` | `'**/*.test.ts'` | Glob suffix (per dir) that detects the presence of tests. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded the `test:node` script, a `packages/*` + `apps/sidecar`
+dir list, and a vitest exclusion set.
+
+## When not to use it
+
+If your test runner discovers packages automatically (no hardcoded path list), this rule is
+unnecessary.

package/docs/rules/ui-primitive-shape.md

@@ -0,0 +1,41 @@
+# `ui-primitive-shape`
+
+> A folder primitive must ship its proof siblings; a flat primitive must carry none at the ui root.
+
+## Why
+
+The primitives root is the one place exempt from folder-per-component: flat single files are fine for
+presentational primitives. But once a primitive graduates to its own folder, it is a real component
+and must carry the same proof-of-behavior siblings (a test, a story) as any feature component. This
+closes the "the ui folder mixes two shapes with no rule" gap: flat = pure presentational; folder =
+tested + storied.
+
+## What it flags
+
+- **Folder primitives** — for each `<uiRoot>/<Name>/<barrelFile>`, each configured role must exist as
+  `<Name>.<role><extension>`; a missing one is flagged.
+- **Flat primitives** — a flat `<uiRoot>/<Name><extension>` (capitalized) that already has a sibling
+  `<Name>.<role><extension>` at the ui root is flagged: those proof files belong inside a `<Name>/`
+  folder.
+
+## Factory
+
+```ts
+createUiPrimitiveShapeRule(options?: UiPrimitiveShapeOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `uiRoot` | `string` | `'apps/web/src/components/ui'` | The primitives root. |
+| `barrelFile` | `string` | `'index.ts'` | Barrel file that marks a folder-primitive. |
+| `roles` | `string[]` | `['test', 'stories']` | Proof-of-behavior sibling roles a folder-primitive must ship. |
+| `extension` | `string` | `'.tsx'` | Extension of primitive and proof files. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded `apps/web/src/components/ui`, the `test`/`stories` roles,
+and the `.tsx` extension.
+
+## When not to use it
+
+If you do not maintain a flat-vs-folder primitive convention or do not colocate stories/tests, skip
+the rule.

package/docs/rules/workspace-graph-parity.md

@@ -0,0 +1,41 @@
+# `workspace-graph-parity`
+
+> Imported `<scope>/*` specifiers must be declared `workspace:*` deps, and tsconfig `references` must
+> mirror those deps.
+
+## Why
+
+A cross-package edge is real in three places at once: the import in source, the `workspace:*` entry in
+`package.json`, and the project reference in `tsconfig.json`. When they drift, a package builds
+locally but breaks on a clean install or a project-graph build. This rule keeps the three in lockstep
+so an edge can never be half-wired.
+
+## What it flags
+
+For each workspace `package.json`:
+
+- **(a) imported ⊆ declared** — every `<scope>/<pkg>` imported under the source dir (test files
+  excluded, self-imports ignored) must appear as a `"<scope>/<pkg>": "workspace:*"` dependency.
+- **(b) references mirror deps** — the tsconfig `references` must reference exactly the declared
+  workspace deps: a declared dep missing from references, or a referenced package that is not a
+  declared dep, is a violation.
+
+## Factory
+
+```ts
+createWorkspaceGraphParityRule(options?: WorkspaceGraphParityOptions): IMetaRule
+```
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `scope` | `string` | `'@nightcore'` | npm scope of workspace packages (all scope regexes are rebuilt from it). |
+| `packageGlobs` | `string[]` | `['packages/*/package.json', 'apps/*/package.json']` | Packages to enforce parity for. |
+| `srcDir` | `string` | `'src'` | Source directory (per package) scanned for imports. |
+| `ciCritical` | `boolean` | `true` | Whether a violation fails CI. |
+
+De-projected from nightcore, which hardcoded the `@nightcore` scope and a `src` source directory.
+
+## When not to use it
+
+If your project does not use the `workspace:*` protocol, or does not use TypeScript project
+references, this rule's assumptions do not hold.

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@noctcore/lint-meta-rules",
+  "version": "0.1.0",
+  "description": "Portable, parameterized lint-meta rules — whole-repo / cross-file invariants ESLint cannot reach — for the @noctcore/harness lint-meta runner.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "lint-meta",
+    "noctcore",
+    "harness",
+    "structure-lock",
+    "monorepo",
+    "convention"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noctcore/eslint-plugins.git",
+    "directory": "packages/lint-meta-rules"
+  },
+  "homepage": "https://github.com/noctcore/eslint-plugins/tree/main/packages/lint-meta-rules",
+  "bugs": "https://github.com/noctcore/eslint-plugins/issues",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@noctcore/harness": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.6.0"
+  }
+}