feat(tsconfig): enable noUncheckedIndexedAccess in the base — 0.1.2

`strict: true` does not turn this on — it is opt-in, and it is the flag that makes
`arr[i]` / `record[key]` honestly `T | undefined`. Without it TypeScript types an
unchecked index as non-nullable, so code like

    const [row] = await db.insert(project).values(input).returning({ id: project.id });
    return row.id;

type-checks and then throws at runtime when the result is empty. Adopting this in a
real consumer (fluxo-arc) immediately surfaced four latent bugs of exactly that shape
in database writes, plus a crash in a string helper.

All framework presets extend base, so react / react-native / next / nest inherit it.

Also adds test/tsconfig.test.js — the tsconfig presets shipped with zero coverage. It
pins the type-safety floor and asserts every preset extends base and never weakens it.
Writing it caught that `nest` relaxes `isolatedModules` / `verbatimModuleSyntax`; that
is a legitimate module-mechanics need (emitDecoratorMetadata + CommonJS decorator
emit), not a safety weakening, so the test separates the two categories.

Consumer impact: this is behaviour-affecting for anyone who EXTENDS the tsconfig
presets — expect to add real guards on first adoption. Released as a patch because no
consumer extends them yet (fluxo-web and fluxo-arc both consume only the ESLint and
Prettier configs).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: a-tokyo

README.md

@@ -29,7 +29,7 @@ Sonar issues before they reach CI. Five stack presets — **plain JS/TS**, **Rea
 Distributed via GitHub URL, pinned to a tag (no build step runs on install — raw ESM):
 
 ```bash
-npm i -D "github:zoldytech/javascript#0.1.1"
+npm i -D "github:zoldytech/javascript#0.1.2"
 ```
 
 ## Usage
@@ -118,6 +118,19 @@ Extend the matching base in `tsconfig.json`:
 Available: `tsconfig/base.json`, `/react.json`, `/react-native.json`, `/next.json`, `/nest.json`
 (framework ones extend base).
 
+The base goes beyond `strict`. Most notably it sets **`noUncheckedIndexedAccess`**, which `strict`
+does _not_ enable: it makes `arr[i]` and `record[key]` honestly `T | undefined`. Without it,
+TypeScript types this as non-nullable and the bug ships:
+
+```ts
+const [row] = await db.insert(project).values(input).returning({ id: project.id });
+return row.id; // `row` is `T | undefined` at runtime; without the flag TS says it is always `T`
+```
+
+Expect to add real guards when you first adopt it — that is the flag doing its job. Also on:
+`noUnusedLocals`, `noUnusedParameters`, `noImplicitReturns`, `noFallthroughCasesInSwitch`,
+`verbatimModuleSyntax`, `isolatedModules`, `forceConsistentCasingInFileNames`.
+
 ## Git hooks (recommended, not shipped)
 
 This package ships no hooks. Wire the recommended pipeline in your own repo:

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zoldytech/javascript",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": true,
   "description": "Zoldytech's JavaScript/TypeScript standards: SonarQube-compatible ESLint presets (Next.js, NestJS, React+Vite, plain JS/TS) plus shared Prettier and tsconfig configs.",
   "license": "MIT",

test/tsconfig.test.js

@@ -0,0 +1,87 @@
+// The tsconfig presets are a published contract, so they get the same guard the ESLint presets do.
+//
+// `strict: true` alone does NOT enable `noUncheckedIndexedAccess` — it is opt-in, and it is the one
+// flag that makes `arr[i]` / `record[key]` honestly `T | undefined`. Without it TypeScript silently
+// types `const [row] = await db.insert(...).returning()` as non-nullable, so `row.id` type-checks
+// and throws at runtime on an empty result. Assert it (and the rest of the floor) so a future edit
+// cannot quietly weaken the bar.
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const readConfig = (name) =>
+  JSON.parse(readFileSync(path.join(here, '..', 'tsconfig', name), 'utf8'));
+
+const PRESETS = ['react.json', 'react-native.json', 'next.json', 'nest.json'];
+
+/**
+ * The type-SAFETY floor: what makes the compiler catch bugs. No preset may weaken these — doing so
+ * is a breaking change to consumers.
+ */
+const SAFETY_FLOOR = {
+  strict: true,
+  noUncheckedIndexedAccess: true,
+  noImplicitReturns: true,
+  noFallthroughCasesInSwitch: true,
+  noUnusedLocals: true,
+  noUnusedParameters: true,
+  forceConsistentCasingInFileNames: true,
+};
+
+/**
+ * Module MECHANICS: the base sets these, but a framework may legitimately override them (NestJS
+ * turns `isolatedModules`/`verbatimModuleSyntax` off because `emitDecoratorMetadata` needs the
+ * full-program, CommonJS decorator emit). They are not a safety bar, so they are asserted on the
+ * base only — never on the presets.
+ */
+const BASE_MECHANICS = {
+  isolatedModules: true,
+  verbatimModuleSyntax: true,
+};
+
+test('base: sets the full type-safety floor', () => {
+  const { compilerOptions } = readConfig('base.json');
+  for (const [flag, expected] of Object.entries(SAFETY_FLOOR)) {
+    assert.equal(
+      compilerOptions[flag],
+      expected,
+      `tsconfig/base.json must set ${flag}: ${expected}`
+    );
+  }
+});
+
+test('base: sets the module mechanics defaults', () => {
+  const { compilerOptions } = readConfig('base.json');
+  for (const [flag, expected] of Object.entries(BASE_MECHANICS)) {
+    assert.equal(
+      compilerOptions[flag],
+      expected,
+      `tsconfig/base.json must set ${flag}: ${expected}`
+    );
+  }
+});
+
+// The framework presets inherit the floor rather than restating it, so `extends` IS the contract:
+// if one stops extending base, it silently loses noUncheckedIndexedAccess and the rest.
+for (const preset of PRESETS) {
+  test(`${preset}: extends base`, () => {
+    assert.equal(readConfig(preset).extends, './base.json', `${preset} must extend ./base.json`);
+  });
+
+  test(`${preset}: does not weaken the type-safety floor`, () => {
+    const { compilerOptions = {} } = readConfig(preset);
+    for (const [flag, expected] of Object.entries(SAFETY_FLOOR)) {
+      if (flag in compilerOptions) {
+        assert.equal(
+          compilerOptions[flag],
+          expected,
+          `${preset} must not weaken ${flag} inherited from base`
+        );
+      }
+    }
+  });
+}

tsconfig/base.json

@@ -8,6 +8,7 @@
     "noImplicitAny": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "forceConsistentCasingInFileNames": true,