feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/wonka/docs/getting-started.md

@@ -0,0 +1,136 @@
+---
+title: Getting Started
+order: 1
+---
+
+This page will explain how to install the Wonka package and
+its basic usage and helper functions.
+
+## Installation
+
+The `wonka` package from `npm` is all you need to install to use
+Wonka. The process is the same with `yarn` and `esy`.
+
+```bash
+yarn add wonka
+# or with npm:
+npm install --save wonka
+# or with esy:
+esy add wonka
+```
+
+For **JavaScript projects**, the package contains both CommonJS and
+ES Modules bundles. For Flow and TypeScript the package also contains
+typings files already, so if you're using either you're already done and
+ready to go.
+
+If you're using **BuckleScript** or `bs-native` you will need to add `"wonka"`
+to your `bs-dependencies` in your `bsconfig.json` configuration file:
+
+```diff
+{
+  "name": "<some_name>",
+  "version": "0.1.0",
+  "sources": ["src"],
+  "bsc-flags": ["-bs-super-errors"],
+  "bs-dependencies": [
++   "wonka"
+  ]
+}
+```
+
+If you're using **Dune** and **Esy** you will need to add `wonka` to
+your `libraries` entry in the respective `dune` configuration file:
+
+```diff
+(library
+  (name some_name)
+  (public_name some_name)
++ (libraries wonka)
+)
+```
+
+## Usage with JavaScript
+
+In most cases you'll simply import or require `wonka` and use its exposed
+methods and utilities. In both CommonJS and ES Modules the Wonka package
+simply exposes all its utilities.
+
+```js
+// With CommonJS
+const { fromArray } = require('wonka');
+// With ES Modules
+import { fromArray } from 'wonka';
+```
+
+There are also some special operators in Wonka that will only be exposed in
+Web/JavaScript environments, like `fromPromise`, `toPromise`,
+or `fromEvent`, or even `debounce` and `throttle`.
+In TypeScript and Flow the typings also expose all types.
+
+There's also a special utility in JavaScript environments to replace the pipeline
+operator. This function is called `pipe` and simply calls functions that it's
+being passed in order with the previous return value.
+
+```js
+import { pipe } from 'wonka';
+
+const output = pipe(
+  'test',
+  x => x + ' this',
+  x => x.toUpperCase()
+);
+
+output; // "TEST THIS"
+```
+
+As shown above, the `pipe` function takes the first argument and passes it
+in order to the other function arguments. The return value of one function will
+be passed on to the next function.
+
+In TypeScript and Flow the `pipe` function is also typed to handle all generics
+in Wonka utilities correctly. Using it will ensure that most of the time you won't
+have to specify the types of any generics manually.
+
+If you're using Babel and the [pipeline proposal plugin](https://babeljs.io/docs/en/babel-plugin-proposal-pipeline-operator), you can just use
+the pipeline operator to do the same and not use the `pipe` helper.
+
+## Usage with Reason
+
+Everything in the Wonka package is exposed under a single module called `Wonka`.
+This module also contains `Wonka.Types`, which contains all internal types of the Wonka
+library, but you will typically not need it.
+
+In `BuckleScript` when you're compiling to JavaScript you will also have access to
+more utilities like `fromPromise`, `toPromise`, `fromEvent`, or even `debounce` and `throttle`.
+These utilities are missing in native compilation, like Dune or `bsb-native`, since they're
+relying on JavaScript APIs like Promises, `window.addEventListener`, and `setTimeout`.
+
+When using Wonka you'd simply either open the module and use its utilities or just
+access them from the `Wonka` module:
+
+```reason
+Wonka.fromValue("test")
+  |> Wonka.map((.x) => x ++ " this")
+  |> Wonka.forEach((.x) => print_endline(x));
+```
+
+It's worth noting that most callbacks in Wonka need to be explicitly uncurried, since
+this will help them compile cleanly to JavaScript.
+
+## Interoperability
+
+In JavaScript environments, Wonka comes with several utilities that make it easier
+to interoperate with JavaScript primitives and other libraries:
+
+- [`fromPromise`](./api/sources.md#frompromise) & [`toPromise`](./api/sinks.md#topromise) can be used to interoperate with Promises
+- [`fromObservable`](./api/sources.md#fromobservable) & [`toObservable`](./api/sinks.md#toobservable) can be used to interoperate with spec-compliant Observables
+- [`fromCallbag`](./api/sources.md#fromcallbag) & [`toCallbag`](./api/sinks.md#tocallbag) can be used to interoperate with spec-compliant Callbags
+
+Furthermore there are a couple of operators that only work in JavaScript environments
+since they need timing primitives, like `setTimeout` and `setInterval`:
+
+- [`delay`](./api/operators.md#delay)
+- [`debounce`](./api/operators.md#debounce)
+- [`throttle`](./api/operators.md#throttle)
+- [`interval`](./api/sources.md#interval)

smart-app-city/frontend/node_modules/wonka/docs/index.md

@@ -0,0 +1,51 @@
+---
+title: Introduction
+order: 0
+---
+
+Wonka is a lightweight iterable and observable library loosely based on
+the [callbag spec](https://github.com/callbag/callbag). It exposes a set of helpers to create streams,
+which are sources of multiple values, which allow you to create, transform
+and consume event streams or iterable sets of data.
+
+## What it is
+
+Wonka is a library for streams _and_ iterables that behaves predictably
+and can be used for many problems where you're dealing with streams of
+values, asynchronous or not.
+
+It's similar to [RxJS](https://github.com/ReactiveX/rxjs) in that it enables asynchronous programming with
+observable streams, with an API that looks like functional programming on
+iterables, but it's also similar to [IxJS](https://github.com/ReactiveX/IxJS) since Wonka streams will run
+synchronously if an iterable source runs synchronously.
+
+It also comes with many operators that users from [RxJS](https://github.com/ReactiveX/rxjs) will be used to.
+
+## Compatibility
+
+Wonka is written in [Reason](https://reasonml.github.io/), a dialect of OCaml, and can hence be used
+for native applications. It is also compiled using [BuckleScript](https://bucklescript.github.io) to plain
+JavaScript and has typings for [TypeScript](https://www.typescriptlang.org/) and [Flow](https://flow.org/).
+
+This means that out of the box Wonka is usable in any project that use the following:
+
+- Plain JavaScript
+- TypeScript
+- Flow
+- Reason/OCaml with BuckleScript
+- Reason/OCaml with `bs-native`
+- Reason/OCaml with Dune and Esy
+
+In summary, Wonka provides a consistent interface in and works across
+TypeScript/Flow/Reason/OCaml environments with full type safety.
+
+## About the docs
+
+As mentioned in the prior section, Wonka supports not one but a couple of
+environments and languages. To accommodate for this, most of the docs
+are written with examples and sections for TypeScript and Reason.
+
+We don't provide examples in most parts of the docs for Flow and OCaml because
+their respective usage is almost identical to TypeScript and Reason, so for
+the most part the examples mostly deal with the differences between a
+TypeScript and a Reason project.

smart-app-city/frontend/node_modules/wonka/docs/migration.md

@@ -0,0 +1,110 @@
+---
+title: Migration
+order: 2
+---
+
+This page lists breaking changes and migration guides for
+various major releases of Wonka.
+
+## v4.0.0
+
+In `v4.0.0` of Wonka, we've migrated to BuckleScript v7 and
+`genType` for automatic type generation for TypeScript. The
+Flow types are derived from the automatic types and are generated
+by `flowgen`.
+
+This may mean that `bsb-native` and Dune/Esy builds are temporarily
+broken, as they haven't been tested yet. If so, they will be fixed
+in a future minor release. Please stick with `v3.2.2` if you're having
+trouble.
+
+This release has no breaking changes for Reason/OCaml in terms of
+API changes. You can use the library exactly as you have before.
+
+**For TypeScript and Flow some APIs have changed**.
+
+### New TypeScript and Flow typings
+
+The type for `Subscription`, `Observer`, and `Subject` have changed.
+These used to be exposed as tuples (fixed-size arrays) in the past,
+but are now compiled to objects, due to the upgrade to BuckleScript v7.
+
+If you're using `subscribe`, `makeSubject`, or `make` you will have
+to change some of your types. If you don't, you won't have to update
+any of your code and can even mix Wonka `v4.0.0` with `v3.2.2` in the
+same bundle.
+
+The `Subscription` type has changed from `[() => void]` to
+`{ unsubscribe: (_: void) => void }`:
+
+```ts
+import { subscribe } from 'wonka';
+
+// Before:
+const [unsubscribe] = subscribe(source);
+// After:
+const { unsubscribe } = subscribe(source);
+```
+
+The `Observer` type has changed similarly, so you'll have to
+update your code if you're using `make`:
+
+```ts
+import { make } from 'wonka';
+
+// Before:
+const source = make(([next, complete]) => /* ... */);
+// After:
+const source = make(({ next, complete }) => /* ... */);
+```
+
+And lastly the `Subject` type has changed as well, so update
+your usage of `makeSubject`:
+
+```ts
+import { makeSubject } from 'wonka';
+
+// Before:
+const [source, next, complete] = makeSubject();
+// After:
+const { source, next, complete } = makeSubject();
+```
+
+### Improvements
+
+The test suite has been rewritten from scratch to improve our
+testing of some tricky edge cases. In most cases operators have
+been updated to behave more nicely and closer to the spec and
+as expected. This is especially true if you're using synchronous
+sources or iterables a lot.
+
+Wonka has reached a much higher test coverage and operators like
+`merge` and `switchMap` will now behave as expected with synchronous
+sources.
+
+This is the list of operators that have changed. If your code has
+been working before, you _shouldn't see any different behaviour_.
+The changed operators will simply have received bugfixes and will
+behave more predictably (and hopefully correctly) in certain edge cases!
+
+- [`buffer`](./api/operators.md#buffer)
+- [`combine`](./api/operators.md#combine)
+- [`debounce`](./api/operators.md#debounce)
+- [`delay`](./api/operators.md#delay)
+- [`sample`](./api/operators.md#sample)
+- [`skipUntil`](./api/operators.md#skipuntil)
+- [`take`](./api/operators.md#take)
+- [`takeLast`](./api/operators.md#takelast)
+- [`takeWhile`](./api/operators.md#takewhile)
+- [`switchMap`](./api/operators.md#switchmap)
+- [`mergeMap`](./api/operators.md#mergemap)
+- [`concatMap`](./api/operators.md#concatmap)
+- [`switchAll`](./api/operators.md#switchall)
+- [`mergeAll`](./api/operators.md#mergeall)
+- [`concatAll`](./api/operators.md#concatall)
+- [`merge`](./api/operators.md#merge)
+- [`concat`](./api/operators.md#concat)
+
+The `take` operator is the only one that has been changed to fix
+a notable new usage case. It can now accept a maximum of `0` or below,
+to close the source immediately.