Please analyze this monorepo and create a comprehensive architectural report covering the following areas:
- What is the overall directory structure? Where are packages/apps located?
- How are packages named and categorized?
- Are there any structural patterns that separate apps from libraries?
- How are package boundaries enforced? (e.g., barrel exports, internal vs public APIs)
- What linting and formatting tools are used? (ESLint, Prettier, Biome, oxc-lint, etc.)
- Where are linter configurations located? (root-level vs per-package)
- What TypeScript configuration strategy is used? (single tsconfig vs per-package)
- What is the TypeScript strictness level? Are .js files permitted?
- What monorepo orchestration tool is used, if any? (pnpm workspaces, Turbo, Nx, Lerna, etc.)
- What testing framework(s) are used for unit tests?
- How are sourcemaps handled for production builds and error tracking?
- What package manager is used?
- How are shared dependencies managed across packages?
- What patterns exist for versioning and releasing packages?
- Are there any changelog generation tools in use? (Changesets, etc.)
- How do components receive configuration? (props, context providers, environment variables)
- Where do components fetch their data from? Do they handle their own data fetching?
- How is external context (locale, timezone, user data, etc.) accessed?
- Are there patterns around dependency injection or accessing global objects?
- What data fetching libraries or patterns are used? (REST clients, GraphQL, etc.)
- How is routing handled? Is there a prescribed routing solution?
- What strategy is used for internationalization (i18n)?
- How are different deployment targets handled? (npm packages, CDN, Module Federation, etc.)
- How are TypeScript type definitions published for consuming applications?
- What is the local development setup? (Storybook, demo apps, etc.)
- How are components tested? (unit tests, integration tests, visual regression, etc.)
- Are there preview environments or PR deployment strategies?
- How is code ownership managed? (CODEOWNERS files, team assignments, etc.)
- What build tools are used? (Vite, Webpack, Rollup, etc.)
- How do individual packages define their deployment strategies?
- Are there patterns for shipping to different targets (npm, CDN, bundled in apps)?
Please provide concrete examples from the codebase wherever possible, including file paths, configuration snippets, and actual usage patterns. Focus on what actually exists in the repo rather than theoretical approaches.