@flare-engine/create 0.4.0

package/templates/topdown/babel.config.js

@@ -0,0 +1,7 @@
+module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+    plugins: ['react-native-worklets/plugin'],
+  };
+};

package/templates/topdown/gitignore

@@ -0,0 +1,8 @@
+node_modules
+public/canvaskit.wasm
+.expo
+dist
+*.log
+.DS_Store
+android
+ios

package/templates/topdown/index.ts

@@ -0,0 +1,4 @@
+import { registerRootComponent } from "expo";
+import { App } from "./src/App";
+
+registerRootComponent(App);

package/templates/topdown/index.web.ts

@@ -0,0 +1,17 @@
+import { LoadSkiaWeb } from "@shopify/react-native-skia/lib/module/web";
+import { registerRootComponent } from "expo";
+
+// Metro picks this file over index.ts on web because package.json's `main` is
+// extensionless. Keeping the web entry separate is not cosmetic: RN-Skia's web
+// module builds its Skia object from global.CanvasKit at module-eval time, so
+// anything that imports Skia must be loaded only after LoadSkiaWeb resolves.
+// A static `import { App }` here would leave Skia permanently hollow and
+// GameView would throw on Skia.Paint.
+//
+// `bun run web` copies canvaskit.wasm into public/, which Expo serves at the
+// web root — that is what locateFile points at.
+void (async () => {
+  await LoadSkiaWeb({ locateFile: (file: string) => `/${file}` });
+  const { App } = await import("./src/App");
+  registerRootComponent(App);
+})();

package/templates/topdown/metro.config.js

@@ -0,0 +1,3 @@
+const { getDefaultConfig } = require('expo/metro-config');
+
+module.exports = getDefaultConfig(__dirname);

package/templates/topdown/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "{{APP_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "main": "index",
+  "scripts": {
+    "start": "expo start",
+    "android": "expo run:android",
+    "ios": "expo run:ios",
+    "web": "node scripts/copy-canvaskit.mjs && expo start --web",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@expo/metro-runtime": "~57.0.0",
+    "@flare-engine/engine": "{{FLARE_VERSION}}",
+    "@flare-engine/physics": "{{FLARE_VERSION}}",
+    "@flare-engine/react": "{{FLARE_VERSION}}",
+    "@flare-engine/tilemap": "{{FLARE_VERSION}}",
+    "@shopify/react-native-skia": "2.6.0",
+    "canvaskit-wasm": "0.41.0",
+    "expo": "~57.0.0",
+    "expo-status-bar": "~57.0.0",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "react-native": "0.86.0",
+    "react-native-reanimated": "~4.5.0",
+    "react-native-safe-area-context": "~5.6.0",
+    "react-native-web": "~0.21.0",
+    "react-native-worklets": "~0.10.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.0",
+    "@types/react": "~19.2.0",
+    "typescript": "^5.5.0"
+  },
+  "trustedDependencies": [
+    "@shopify/react-native-skia"
+  ]
+}

package/templates/topdown/scripts/copy-canvaskit.mjs

@@ -0,0 +1,15 @@
+import { copyFile, mkdir } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+
+// LoadSkiaWeb imports canvaskit-wasm/bin/full/canvaskit, so the binary served
+// at / must be the `full` build (~8 MB). bin/canvaskit.wasm is a smaller,
+// ABI-incompatible variant — serving it fails at runtime, not at build time.
+const require = createRequire(import.meta.url);
+const source = require.resolve("canvaskit-wasm/bin/full/canvaskit.wasm");
+const targetDir = join(process.cwd(), "public");
+
+await mkdir(targetDir, { recursive: true });
+await copyFile(source, join(targetDir, "canvaskit.wasm"));
+
+console.log("copy-canvaskit: public/canvaskit.wasm");

package/templates/topdown/src/App.tsx

@@ -0,0 +1,138 @@
+import {
+  Position,
+  Sprite,
+  TilemapRenderer,
+  buildSolidGrid,
+  createProceduralAtlas,
+  extractColliders,
+  moveAndSlideInto,
+} from "@flare-engine/engine";
+import type {
+  GameContextValue,
+  VirtualJoystickState,
+} from "@flare-engine/engine";
+import { GameView, VirtualJoystick, skiaAtlasModule } from "@flare-engine/react";
+import type React from "react";
+import { useMemo, useRef } from "react";
+import { StyleSheet, View } from "react-native";
+import { SafeAreaProvider } from "react-native-safe-area-context";
+import { DOOR_COL, DOOR_ROW, TILE_SIZE, isTouchingDoor, loadMap, openDoor } from "./map";
+
+const SPEED = 96;
+const PLAYER_HALF = 6;
+const PLAYER_START = { x: 24, y: 152 };
+
+// Frame order (grass/wall/rock/door-closed/door-open at localId 0-4, x=0/16/32/48/64)
+// must stay aligned with the tileset GID math in map.ts (TILE_GRASS=1 → localId=0, etc.).
+// Reordering frames here without updating CHAR_TO_GID silently breaks tile rendering.
+const ATLAS_FRAMES = [
+  { name: "grass", w: TILE_SIZE, h: TILE_SIZE, color: 0xff3a7d44 },
+  { name: "wall", w: TILE_SIZE, h: TILE_SIZE, color: 0xff5a5a66 },
+  { name: "rock", w: TILE_SIZE, h: TILE_SIZE, color: 0xff8c8c8c },
+  { name: "doorClosed", w: TILE_SIZE, h: TILE_SIZE, color: 0xff8b5a2b },
+  { name: "doorOpen", w: TILE_SIZE, h: TILE_SIZE, color: 0xffd9b273 },
+  { name: "player", w: 12, h: 12, color: 0xfff2e9d8 },
+] as const;
+
+/**
+ * Top-down starter: a 4x8 house on an open field, with rocks and an openable
+ * door. Walking into the closed door opens it — a `SolidGrid` cell flip plus
+ * a tile-GID swap for the render, both zero-alloc (see `openDoor` in
+ * ./map.ts). Walls, rocks, and the door while closed all block movement the
+ * same way; the door stops blocking once opened. A virtual joystick drives
+ * the player; the camera follows.
+ */
+export function App(): React.ReactElement {
+  const dirRef = useRef({ x: 0, y: 0 });
+  const tilemapRef = useRef<TilemapRenderer | null>(null);
+
+  const config = useMemo(
+    () => ({
+      onRenderBackground: (ctx: GameContextValue) => {
+        tilemapRef.current?.drawInto(ctx.camera, ctx.batch);
+      },
+    }),
+    [],
+  );
+
+  const handleReady = (ctx: GameContextValue): void => {
+    const atlas = createProceduralAtlas(skiaAtlasModule, ATLAS_FRAMES);
+    const map = loadMap();
+
+    // Narrow to the single tile layer once, up front — openDoor needs a
+    // mutable reference to its `tiles` array every time the door opens.
+    const groundLayer = map.layers[0];
+    if (groundLayer === undefined || groundLayer.type !== "tile") return;
+
+    const tilemap = new TilemapRenderer(map);
+    tilemap.setTilesetImage("tiles", atlas.image);
+    tilemapRef.current = tilemap;
+
+    const grid = buildSolidGrid(
+      map.width,
+      map.height,
+      TILE_SIZE,
+      extractColliders(map),
+    );
+    const doorIndex = DOOR_ROW * grid.width + DOOR_COL;
+
+    const player = ctx.world.spawn();
+    ctx.world.add(player, Position, { x: PLAYER_START.x, y: PLAYER_START.y });
+    const playerFrame = atlas.sheet.frames.find((f) => f.name === "player");
+    if (playerFrame) {
+      ctx.world.add(player, Sprite, {
+        image: atlas.image,
+        frame: playerFrame,
+        z: 1,
+        width: playerFrame.w,
+        height: playerFrame.h,
+        anchor: { x: 0.5, y: 0.5 },
+      });
+    }
+
+    ctx.camera.zoom = 2;
+    const target = { x: PLAYER_START.x, y: PLAYER_START.y };
+    ctx.camera.follow(target);
+
+    ctx.loop.onUpdate.add((dt) => {
+      const pos = ctx.world.get(player, Position);
+      if (!pos) return;
+
+      const dx = dirRef.current.x * SPEED * dt;
+      const dy = dirRef.current.y * SPEED * dt;
+
+      // Bump-to-open: the joystick is the only input this template wires up,
+      // so walking into the closed door is the open action — no extra button.
+      // Checked against the intended (pre-collision) position so the door
+      // opens the same frame the player walks into it, not one frame late.
+      if (grid.solid[doorIndex] !== 0 && isTouchingDoor(pos.x + dx, pos.y + dy, PLAYER_HALF, PLAYER_HALF)) {
+        openDoor(groundLayer, grid);
+      }
+
+      moveAndSlideInto(grid, pos.x, pos.y, dx, dy, PLAYER_HALF, PLAYER_HALF, pos);
+      target.x = pos.x;
+      target.y = pos.y;
+    });
+  };
+
+  const handleJoystick = (state: VirtualJoystickState): void => {
+    dirRef.current.x = state.direction.x;
+    dirRef.current.y = state.direction.y;
+  };
+
+  return (
+    <SafeAreaProvider>
+      <View style={styles.root}>
+        <GameView config={config} onReady={handleReady} style={styles.game}>
+          <VirtualJoystick style={styles.joystick} onStateChange={handleJoystick} />
+        </GameView>
+      </View>
+    </SafeAreaProvider>
+  );
+}
+
+const styles = StyleSheet.create({
+  root: { flex: 1, backgroundColor: "#000" },
+  game: { flex: 1 },
+  joystick: { position: "absolute", left: 24, bottom: 24 },
+});

package/templates/topdown/src/map.ts

@@ -0,0 +1,126 @@
+import type { SolidGrid } from '@flare-engine/physics';
+import { parseTiled } from '@flare-engine/tilemap';
+import type { TileLayer, TilemapData } from '@flare-engine/tilemap';
+
+export const TILE_SIZE = 16;
+
+export const TILE_GRASS = 1;
+export const TILE_WALL = 2;
+export const TILE_ROCK = 3;
+export const TILE_DOOR_CLOSED = 4;
+export const TILE_DOOR_OPEN = 5;
+
+const CHAR_TO_GID: Record<string, number> = {
+  '.': TILE_GRASS,
+  '#': TILE_WALL,
+  R: TILE_ROCK,
+  D: TILE_DOOR_CLOSED,
+};
+
+/** ASCII source for a 4x8 house on an open field. `#` wall, `.` grass,
+ *  `R` rock, `D` door (starts closed). Walls, rocks, and the closed door all
+ *  collide; the door stops colliding once opened at runtime — see
+ *  `openDoor` below. */
+export const MAP_ART: readonly string[] = [
+  '............',
+  '....####....',
+  '....#..#....',
+  '..R.#..#....',
+  '....#..#....',
+  '....#..#.R..',
+  '....#..#....',
+  '....#..#....',
+  '....#D##....',
+  '....R.......',
+];
+
+/** Scan `art` for the door character once at module load; throws if a future
+ *  edit to MAP_ART drops the door, instead of silently shipping a doorless map. */
+function findDoorTile(art: readonly string[]): { row: number; col: number } {
+  for (let row = 0; row < art.length; row++) {
+    const col = art[row]?.indexOf('D') ?? -1;
+    if (col !== -1) return { row, col };
+  }
+  throw new Error('map.ts: MAP_ART has no door ("D") tile');
+}
+
+const DOOR_TILE = findDoorTile(MAP_ART);
+export const DOOR_ROW = DOOR_TILE.row;
+export const DOOR_COL = DOOR_TILE.col;
+export const DOOR_WORLD_X = DOOR_COL * TILE_SIZE + TILE_SIZE / 2;
+export const DOOR_WORLD_Y = DOOR_ROW * TILE_SIZE + TILE_SIZE / 2;
+
+/** Build a Tiled `.tmj`-shaped JSON object from the ASCII art.
+ *  Swapping in a real editor-made map is a drop-in change:
+ *  `parseTiled(require('./zone1.tmj'))`. */
+export function buildTiledMapJson(art: readonly string[] = MAP_ART): unknown {
+  const height = art.length;
+  const width = art[0]?.length ?? 0;
+  const data: number[] = [];
+  for (const row of art) {
+    for (const ch of row) {
+      data.push(CHAR_TO_GID[ch] ?? 0);
+    }
+  }
+  return {
+    width,
+    height,
+    tilewidth: TILE_SIZE,
+    tileheight: TILE_SIZE,
+    orientation: 'orthogonal',
+    layers: [
+      {
+        type: 'tilelayer',
+        name: 'ground',
+        width,
+        height,
+        data,
+        visible: true,
+        opacity: 1,
+      },
+    ],
+    tilesets: [
+      {
+        firstgid: 1,
+        name: 'tiles',
+        tilewidth: TILE_SIZE,
+        tileheight: TILE_SIZE,
+        columns: 5,
+        tilecount: 5,
+        image: 'procedural://tiles',
+        imagewidth: 80,
+        imageheight: 16,
+        tiles: [
+          { id: TILE_WALL - 1, properties: [{ name: 'solid', type: 'bool', value: true }] },
+          { id: TILE_ROCK - 1, properties: [{ name: 'solid', type: 'bool', value: true }] },
+          { id: TILE_DOOR_CLOSED - 1, properties: [{ name: 'solid', type: 'bool', value: true }] },
+        ],
+      },
+    ],
+  };
+}
+
+export function loadMap(): TilemapData {
+  return parseTiled(buildTiledMapJson());
+}
+
+/** True while an AABB centered at (`x`, `y`) with half-extents (`halfW`,
+ *  `halfH`) overlaps the door tile. Pure and zero-alloc — safe to call every
+ *  frame from the game loop. */
+export function isTouchingDoor(x: number, y: number, halfW: number, halfH: number): boolean {
+  const halfTile = TILE_SIZE / 2;
+  return Math.abs(x - DOOR_WORLD_X) <= halfW + halfTile && Math.abs(y - DOOR_WORLD_Y) <= halfH + halfTile;
+}
+
+/**
+ * Open the door: flips its cell in the collision grid so it stops blocking
+ * movement, and swaps its tile GID so the renderer draws the open frame
+ * instead of the closed one. Both are plain index writes into arrays the
+ * engine already owns (`SolidGrid.solid`, `TileLayer.tiles`) — no grid
+ * rebuild, no allocation. Idempotent: calling it again is a no-op.
+ */
+export function openDoor(groundLayer: TileLayer, grid: SolidGrid): void {
+  const idx = DOOR_ROW * grid.width + DOOR_COL;
+  grid.solid[idx] = 0;
+  groundLayer.tiles[idx] = TILE_DOOR_OPEN;
+}

package/templates/topdown/tests/tilemap.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  buildSolidGrid,
+  isBlockedAABB,
+  moveAndSlideInto,
+} from '@flare-engine/physics';
+import {
+  extractColliders,
+} from '@flare-engine/tilemap';
+import {
+  DOOR_COL,
+  DOOR_ROW,
+  DOOR_WORLD_X,
+  DOOR_WORLD_Y,
+  TILE_DOOR_CLOSED,
+  TILE_DOOR_OPEN,
+  TILE_ROCK,
+  TILE_SIZE,
+  TILE_WALL,
+  buildTiledMapJson,
+  isTouchingDoor,
+  loadMap,
+  openDoor,
+} from '../src/map';
+
+const MAP_WIDTH = 12;
+const MAP_HEIGHT = 10;
+const PLAYER_HALF = 6;
+// PLAYER_START from App.tsx: {x:24, y:152} -> tile col=1, row=9, char='.'
+const PLAYER_X = 24;
+const PLAYER_Y = 152;
+
+// House top wall (row=1, col=4). World center = (4*16+8, 1*16+8).
+const WALL_X = 72;
+const WALL_Y = 24;
+
+// Rock at (row=3, col=2). World center = (2*16+8, 3*16+8).
+const ROCK_X = 40;
+const ROCK_Y = 56;
+
+/** Load a fresh map + ground layer + solid grid for one test — every test
+ *  gets its own SolidGrid so openDoor in one test cannot leak into another. */
+function setup() {
+  const map = loadMap();
+  const groundLayer = map.layers[0];
+  if (groundLayer === undefined || groundLayer.type !== 'tile') {
+    throw new Error('expected a tile layer at index 0');
+  }
+  const grid = buildSolidGrid(map.width, map.height, TILE_SIZE, extractColliders(map));
+  return { map, groundLayer, grid };
+}
+
+describe('buildTiledMapJson', () => {
+  test('produces correct shape, dimensions and known GIDs', () => {
+    const json = buildTiledMapJson() as {
+      width: number;
+      height: number;
+      tilewidth: number;
+      tileheight: number;
+      layers: Array<{ type: string; data: number[] }>;
+      tilesets: Array<{ name: string; firstgid: number }>;
+    };
+
+    expect(json.width).toBe(MAP_WIDTH);
+    expect(json.height).toBe(MAP_HEIGHT);
+    expect(json.tilewidth).toBe(TILE_SIZE);
+    expect(json.tileheight).toBe(TILE_SIZE);
+
+    const layer = json.layers[0];
+    expect(layer?.type).toBe('tilelayer');
+
+    const data = layer?.data ?? [];
+    // House top wall corner (row=1, col=4) -> '#' -> TILE_WALL
+    expect(data[1 * MAP_WIDTH + 4]).toBe(TILE_WALL);
+    // Rock (row=3, col=2) -> 'R' -> TILE_ROCK
+    expect(data[3 * MAP_WIDTH + 2]).toBe(TILE_ROCK);
+    // Door (row=8, col=5) -> 'D' -> starts closed
+    expect(data[DOOR_ROW * MAP_WIDTH + DOOR_COL]).toBe(TILE_DOOR_CLOSED);
+
+    expect(json.tilesets[0]?.name).toBe('tiles');
+  });
+});
+
+describe('parseTiled round-trip', () => {
+  test('produces correct TilemapData with solid tile marks', () => {
+    const map = loadMap();
+
+    expect(map.width).toBe(MAP_WIDTH);
+    expect(map.height).toBe(MAP_HEIGHT);
+    expect(map.tileWidth).toBe(TILE_SIZE);
+    expect(map.tileHeight).toBe(TILE_SIZE);
+
+    expect(map.layers.length).toBe(1);
+    expect(map.layers[0]?.type).toBe('tile');
+
+    expect(map.tilesets.length).toBe(1);
+    const ts = map.tilesets[0];
+    expect(ts?.name).toBe('tiles');
+
+    // wall, rock, and the closed door must be solid; localId = gid - firstGid
+    expect(ts?.solidTiles.has(TILE_WALL - 1)).toBe(true);
+    expect(ts?.solidTiles.has(TILE_ROCK - 1)).toBe(true);
+    expect(ts?.solidTiles.has(TILE_DOOR_CLOSED - 1)).toBe(true);
+    // grass (localId=0) is not solid
+    expect(ts?.solidTiles.has(0)).toBe(false);
+  });
+});
+
+describe('extractColliders', () => {
+  test('house walls, rocks, and the closed door are solid; interior floor is not', () => {
+    const map = loadMap();
+    const colliders = extractColliders(map);
+    const solidSet = new Set(colliders.map((c) => `${c.row},${c.col}`));
+
+    // House top wall corner and a rock
+    expect(solidSet.has('1,4')).toBe(true);
+    expect(solidSet.has('3,2')).toBe(true);
+    // Closed door
+    expect(solidSet.has(`${DOOR_ROW},${DOOR_COL}`)).toBe(true);
+    // Interior floor tile (row=4, col=5)
+    expect(solidSet.has('4,5')).toBe(false);
+  });
+});
+
+describe('isTouchingDoor', () => {
+  test('true when the AABB overlaps the door tile, false far away', () => {
+    expect(isTouchingDoor(DOOR_WORLD_X, DOOR_WORLD_Y, PLAYER_HALF, PLAYER_HALF)).toBe(true);
+    expect(isTouchingDoor(PLAYER_X, PLAYER_Y, PLAYER_HALF, PLAYER_HALF)).toBe(false);
+  });
+});
+
+describe('openDoor', () => {
+  test('flips the solid-grid cell and swaps the tile GID', () => {
+    const { groundLayer, grid } = setup();
+    const idx = DOOR_ROW * grid.width + DOOR_COL;
+
+    expect(grid.solid[idx]).toBe(1);
+    expect(groundLayer.tiles[idx]).toBe(TILE_DOOR_CLOSED);
+
+    openDoor(groundLayer, grid);
+
+    expect(grid.solid[idx]).toBe(0);
+    expect(groundLayer.tiles[idx]).toBe(TILE_DOOR_OPEN);
+  });
+});
+
+describe('collision: wall, rock, and door', () => {
+  test('wall and rock block; PLAYER_START is open', () => {
+    const { grid } = setup();
+
+    expect(isBlockedAABB(grid, WALL_X, WALL_Y, PLAYER_HALF, PLAYER_HALF)).toBe(true);
+    expect(isBlockedAABB(grid, ROCK_X, ROCK_Y, PLAYER_HALF, PLAYER_HALF)).toBe(true);
+    expect(isBlockedAABB(grid, PLAYER_X, PLAYER_Y, PLAYER_HALF, PLAYER_HALF)).toBe(false);
+  });
+
+  test('closed door blocks; open door does not; wall and rock are unaffected by opening it', () => {
+    const { groundLayer, grid } = setup();
+
+    expect(isBlockedAABB(grid, DOOR_WORLD_X, DOOR_WORLD_Y, PLAYER_HALF, PLAYER_HALF)).toBe(true);
+
+    openDoor(groundLayer, grid);
+
+    expect(isBlockedAABB(grid, DOOR_WORLD_X, DOOR_WORLD_Y, PLAYER_HALF, PLAYER_HALF)).toBe(false);
+    // Opening the door must not touch any other cell.
+    expect(isBlockedAABB(grid, WALL_X, WALL_Y, PLAYER_HALF, PLAYER_HALF)).toBe(true);
+    expect(isBlockedAABB(grid, ROCK_X, ROCK_Y, PLAYER_HALF, PLAYER_HALF)).toBe(true);
+  });
+
+  test('moveAndSlideInto: closed door blocks approach; opening it lets the same move through', () => {
+    // Just south of the door tile (row=8 spans y=128..144), moving north (dy<0).
+    const { groundLayer, grid } = setup();
+    const startX = DOOR_WORLD_X;
+    const startY = 150;
+
+    const blocked = { x: startX, y: startY };
+    moveAndSlideInto(grid, startX, startY, 0, -10, PLAYER_HALF, PLAYER_HALF, blocked);
+    expect(blocked.y).toBe(startY); // door still closed — no movement
+
+    openDoor(groundLayer, grid);
+
+    const opened = { x: startX, y: startY };
+    moveAndSlideInto(grid, startX, startY, 0, -10, PLAYER_HALF, PLAYER_HALF, opened);
+    expect(opened.y).toBe(startY - 10); // door open — the same move now succeeds
+  });
+
+  test('moveAndSlideInto: blocks x-movement into a wall; allows y-movement into open space', () => {
+    const { grid } = setup();
+
+    // House right side wall is col=7 (x starts at 112). Approach from just west of it.
+    const wallBlockX = 105;
+    const out1 = { x: wallBlockX, y: WALL_Y + 32 };
+    moveAndSlideInto(grid, wallBlockX, WALL_Y + 32, 10, 0, PLAYER_HALF, PLAYER_HALF, out1);
+    expect(out1.x).toBe(wallBlockX); // x unchanged — wall blocks it
+
+    // PLAYER_START position with dy=2 stays on open field grass -> movement applies
+    const out2 = { x: PLAYER_X, y: PLAYER_Y };
+    moveAndSlideInto(grid, PLAYER_X, PLAYER_Y, 0, 2, PLAYER_HALF, PLAYER_HALF, out2);
+    expect(out2.x).toBe(PLAYER_X);     // x unchanged — no dx
+    expect(out2.y).toBe(PLAYER_Y + 2); // y advances
+  });
+});

package/templates/topdown/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "jsx": "react-native",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "include": ["src", "index.ts", "index.web.ts"]
+}