@calimero-network/agent-skills 0.2.0 → 0.4.0

package/skills/calimero-rust-sdk/references/state-collections.md

@@ -1,39 +1,120 @@
 # CRDT State Collections
 
-Calimero provides conflict-free replicated data types for application state. These are the only correct way to store persistent, shared state.
+Calimero provides conflict-free replicated data types for application state. All collections are
+imported from `calimero_storage::collections`.
+
+> **Critical:** Do NOT use `calimero_sdk::state::*` — that path no longer exists. The correct import
+> is `calimero_storage::collections::*`.
 
 ## Available Collections
 
-| Type | Use for | std equivalent |
-| --- | --- | --- |
-| `calimero_sdk::state::Map<K, V>` | Key-value mapping | `HashMap<K, V>` |
-| `calimero_sdk::state::Set<T>` | Unique values | `HashSet<T>` |
-| `calimero_sdk::state::Vector<T>` | Ordered list | `Vec<T>` |
-| `calimero_sdk::state::UnorderedMap<K, V>` | Unordered map | `HashMap<K, V>` |
+| Type                      | Use for                                 | Notes                                              |
+| ------------------------- | --------------------------------------- | -------------------------------------------------- |
+| `UnorderedMap<K, V>`      | Key-value mapping                       | Most collection ops return `Result<>` — use `?`    |
+| `UnorderedSet<T>`         | Unique value set                        |                                                    |
+| `Vector<T>`               | Ordered list (append-only)              |                                                    |
+| `LwwRegister<T>`          | Single last-write-wins value            | Wrap map values: `UnorderedMap<K, LwwRegister<V>>` |
+| `Counter`                 | Grow-only counter (GCounter by default) | `.increment()`, `.value()`                         |
+| `Counter<true>`           | PN-Counter (supports decrement)         | Same API + `.decrement()`                          |
+| `FrozenStorage<T>`        | Immutable content-addressed entries     |                                                    |
+| `UserStorage<T>`          | Per-member isolated storage             | Not synced to other members                        |
+| `ReplicatedGrowableArray` | CRDT text / ordered sequence            | Collaborative editing                              |
+
+## Import
+
+```rust
+use calimero_storage::collections::{
+    Counter, FrozenStorage, LwwRegister, ReplicatedGrowableArray,
+    UnorderedMap, UnorderedSet, UserStorage, Vector,
+};
+```
 
 ## Usage
 
 ```rust
-use calimero_sdk::state::{Map, Vector};
+use calimero_sdk::app;
+use calimero_sdk::borsh::{BorshDeserialize, BorshSerialize};
+use calimero_storage::collections::{LwwRegister, UnorderedMap, Vector, Counter};
 
-#[derive(Default, BorshDeserialize, BorshSerialize)]
+#[app::state]
+#[derive(Debug, BorshSerialize, BorshDeserialize)]
+#[borsh(crate = "calimero_sdk::borsh")]
 pub struct AppState {
-    items: Map<String, String>,
-    log: Vector<String>,
+    // Map values wrapped in LwwRegister for CRDT merge
+    items:   UnorderedMap<String, LwwRegister<String>>,
+    log:     Vector<String>,
+    counter: Counter,
 }
 
 #[app::logic]
 impl AppState {
-    pub fn set(&mut self, key: String, value: String) {
-        self.items.insert(key, value);
+    pub fn set(&mut self, key: String, value: String) -> app::Result<()> {
+        self.items.insert(key, value.into())?;
+        Ok(())
+    }
+
+    pub fn get(&self, key: &str) -> app::Result<Option<String>> {
+        Ok(self.items.get(key)?.map(|v| v.get().clone()))
     }
 
-    pub fn get(&self, key: &str) -> Option<&String> {
-        self.items.get(key)
+    pub fn append(&mut self, entry: String) -> app::Result<()> {
+        self.log.push(entry)?;
+        Ok(())
     }
 
-    pub fn append(&mut self, entry: String) {
-        self.log.push(entry);
+    pub fn increment(&mut self) -> app::Result<()> {
+        self.counter.increment()?;
+        Ok(())
+    }
+}
+```
+
+## UnorderedMap patterns
+
+```rust
+// Insert
+self.items.insert(key, value.into())?;
+
+// Get (returns Option<LwwRegister<V>>)
+let val = self.items.get(&key)?.map(|v| v.get().clone());
+
+// Contains
+let exists = self.items.contains(&key)?;
+
+// Remove
+let old = self.items.remove(&key)?;
+
+// All entries
+let all: Vec<(K, V)> = self.items.entries()?.collect();
+
+// In-place mutation via guard
+if let Some(mut guard) = self.items.get_mut(&key)? {
+    guard.set(new_value);
+}
+
+// Entry API (like HashMap::entry)
+use calimero_storage::collections::unordered_map::Entry;
+let entry = self.items.entry(key)?;
+let val = entry.or_insert(LwwRegister::new(default_value))?;
+
+// Length
+let n = self.items.len()?;
+
+// Clear
+self.items.clear()?;
+```
+
+## Constructor
+
+Collections must be initialized with `::new()` — there is no Default impl:
+
+```rust
+#[app::init]
+pub fn init() -> AppState {
+    AppState {
+        items:   UnorderedMap::new(),
+        log:     Vector::new(),
+        counter: Counter::new(),
     }
 }
 ```
@@ -41,10 +122,14 @@ impl AppState {
 ## Keys and values must implement
 
 - `BorshSerialize + BorshDeserialize`
-- `Clone` (for most operations)
+- Values in UnorderedMap are typically wrapped in `LwwRegister<V>` — this handles conflict
+  resolution automatically
 
 ## Important
 
-CRDT collections handle concurrent writes from different context members automatically —
-you never need to manually resolve conflicts. Writes from different members are merged
-deterministically using the DAG-based sync engine.
+CRDT collections handle concurrent writes from different context members automatically — you never
+need to manually resolve conflicts. Writes from different members are merged deterministically using
+the DAG-based sync engine.
+
+Collection operations are **fallible** — always propagate errors with `?`. Panicking inside a WASM
+method aborts the execution and rolls back state.

package/skills/calimero-rust-sdk/references/user-and-frozen-storage.md

@@ -0,0 +1,169 @@
+# UserStorage and FrozenStorage
+
+Two specialised CRDT collection types for per-member and immutable data.
+
+---
+
+## UserStorage\<T\>
+
+Stores a separate value of type `T` per context member (keyed by public key). Each member can only
+read/write their own value via the current executor identity. Reading another member's value
+requires explicitly passing their public key.
+
+`T` must implement `BorshSerialize + BorshDeserialize + Mergeable + Default`.
+
+### Simple example (single value per user)
+
+```rust
+use calimero_storage::collections::{LwwRegister, UserStorage};
+
+#[app::state]
+pub struct AppState {
+    // Each member stores their own string value
+    user_names: UserStorage<LwwRegister<String>>,
+}
+
+#[app::logic]
+impl AppState {
+    // Write the current executor's value
+    pub fn set_my_name(&mut self, name: String) -> app::Result<()> {
+        self.user_names.insert(name.into())?;
+        Ok(())
+    }
+
+    // Read the current executor's value
+    pub fn get_my_name(&self) -> app::Result<Option<String>> {
+        Ok(self.user_names.get()?.map(|v| v.get().clone()))
+    }
+
+    // Read a specific user's value
+    pub fn get_name_for(&self, user_key: calimero_sdk::PublicKey) -> app::Result<Option<String>> {
+        Ok(self.user_names.get_for_user(&user_key)?.map(|v| v.get().clone()))
+    }
+}
+```
+
+### Nested example (map per user)
+
+When `T` is a collection, it must implement `Mergeable` manually (or via `#[derive(Mergeable)]`):
+
+```rust
+use calimero_sdk::borsh::{BorshDeserialize, BorshSerialize};
+use calimero_storage::collections::{LwwRegister, Mergeable, UnorderedMap, UserStorage};
+
+#[derive(Debug, BorshSerialize, BorshDeserialize, Default)]
+#[borsh(crate = "calimero_sdk::borsh")]
+struct UserKvMap {
+    map: UnorderedMap<String, LwwRegister<String>>,
+}
+
+impl Mergeable for UserKvMap {
+    fn merge(&mut self, other: &Self)
+        -> Result<(), calimero_storage::collections::crdt_meta::MergeError>
+    {
+        self.map.merge(&other.map)
+    }
+}
+
+#[app::state]
+pub struct AppState {
+    user_data: UserStorage<UserKvMap>,
+}
+
+#[app::logic]
+impl AppState {
+    pub fn set_user_kv(&mut self, key: String, value: String) -> app::Result<()> {
+        // get-modify-put pattern
+        let mut data = self.user_data.get()?.unwrap_or_default();
+        data.map.insert(key, value.into())?;
+        self.user_data.insert(data)?;
+        Ok(())
+    }
+
+    pub fn get_user_kv(&self, key: &str) -> app::Result<Option<String>> {
+        let data = self.user_data.get()?;
+        match data {
+            Some(d) => Ok(d.map.get(key)?.map(|v| v.get().clone())),
+            None => Ok(None),
+        }
+    }
+}
+```
+
+### Key methods
+
+| Method                           | Description                      |
+| -------------------------------- | -------------------------------- |
+| `insert(value: T)?`              | Store value for current executor |
+| `get()?`                         | Get value for current executor   |
+| `get_for_user(key: &PublicKey)?` | Get value for a specific user    |
+
+---
+
+## FrozenStorage\<T\>
+
+Content-addressed, **immutable** storage. Values are keyed by their SHA-256 hash. Once inserted, a
+value can never be modified or deleted. All members share the same frozen entries (unlike
+`UserStorage`).
+
+`T` must implement `BorshSerialize + BorshDeserialize + Into<FrozenValue<T>>`. Typically `T` is
+`String` or a `Vec<u8>`.
+
+```rust
+use calimero_storage::collections::FrozenStorage;
+
+#[app::state]
+pub struct AppState {
+    frozen: FrozenStorage<String>,
+}
+
+#[app::logic]
+impl AppState {
+    /// Insert a value — returns its 32-byte SHA-256 hash
+    pub fn add_frozen(&mut self, value: String) -> app::Result<[u8; 32]> {
+        let hash = self.frozen.insert(value.into())?;
+        Ok(hash)
+    }
+
+    /// Retrieve by hash
+    pub fn get_frozen(&self, hash: [u8; 32]) -> app::Result<Option<String>> {
+        Ok(self.frozen.get(&hash)?.map(|v| v.clone()))
+    }
+}
+```
+
+### Typical usage pattern
+
+Since hashes are `[u8; 32]`, encode them as hex or base58 strings for JSON:
+
+```rust
+use hex;
+
+pub fn add_frozen(&mut self, value: String) -> app::Result<String> {
+    let hash = self.frozen.insert(value.into())?;
+    Ok(hex::encode(hash))  // return as hex string for JSON clients
+}
+
+pub fn get_frozen(&self, hash_hex: String) -> app::Result<Option<String>> {
+    let mut hash = [0u8; 32];
+    hex::decode_to_slice(&hash_hex, &mut hash)
+        .map_err(|_| /* your error type */)?;
+    Ok(self.frozen.get(&hash)?.map(|v| v.clone()))
+}
+```
+
+### Frozen storage key methods
+
+| Method                     | Description                          |
+| -------------------------- | ------------------------------------ |
+| `insert(value: T.into())?` | Store value, returns `[u8; 32]` hash |
+| `get(&hash)?`              | Retrieve value by hash               |
+
+---
+
+## Cargo.toml — add hex for hash encoding
+
+```toml
+[dependencies]
+hex = "0.4"
+```

package/skills/calimero-rust-sdk/rules/app-macro-placement.md

@@ -29,6 +29,9 @@ impl AppState {
 }
 ```
 
-**Why:** `#[app::state]` and `#[app::logic]` are proc macros that transform impl blocks to register the type with the SDK runtime. The struct itself only needs the derive macros (`Default`, `BorshDeserialize`, `BorshSerialize`).
+**Why:** `#[app::state]` and `#[app::logic]` are proc macros that transform impl blocks to register
+the type with the SDK runtime. The struct itself only needs the derive macros (`Default`,
+`BorshDeserialize`, `BorshSerialize`).
 
-**Also:** `#[app::init]` marks the constructor — called once when the context is created. It must return the state type, not `Self`.
+**Also:** `#[app::init]` marks the constructor — called once when the context is created. It must
+return the state type, not `Self`.

package/skills/calimero-rust-sdk/rules/no-std-collections.md

@@ -22,6 +22,9 @@ pub struct AppState {
 }
 ```
 
-**Why:** `std::collections` types do not participate in the CRDT merge process. Data written to them by one node will never reach other context members. The bug is silent — the app compiles and runs correctly on one node, but state diverges in multi-member contexts.
+**Why:** `std::collections` types do not participate in the CRDT merge process. Data written to them
+by one node will never reach other context members. The bug is silent — the app compiles and runs
+correctly on one node, but state diverges in multi-member contexts.
 
-**Applies to:** `HashMap`, `BTreeMap`, `HashSet`, `BTreeSet`, `Vec` (for shared state). `Vec` is fine for temporary local values inside a method, just not as a field in the state struct.
+**Applies to:** `HashMap`, `BTreeMap`, `HashSet`, `BTreeSet`, `Vec` (for shared state). `Vec` is
+fine for temporary local values inside a method, just not as a field in the state struct.

package/skills/calimero-rust-sdk/rules/state-derives.md

@@ -0,0 +1,45 @@
+# Rule: State struct must derive Default, BorshDeserialize, BorshSerialize
+
+The three derives are all required. Missing any one of them causes a **runtime panic**, not a
+compile error — the app will install and start, then crash when the context is first accessed.
+
+## WRONG — missing derives:
+
+```rust
+// ✗ Missing all derives — runtime panic on first call
+pub struct AppState {
+    items: UnorderedMap<String, String>,
+}
+
+// ✗ Missing BorshSerialize — state cannot be persisted
+#[derive(Default, BorshDeserialize)]
+pub struct AppState {
+    items: UnorderedMap<String, String>,
+}
+```
+
+## CORRECT:
+
+```rust
+#[derive(Default, BorshDeserialize, BorshSerialize)]
+pub struct AppState {
+    items: UnorderedMap<String, String>,
+}
+```
+
+## What each derive does
+
+| Derive             | Required for                                               |
+| ------------------ | ---------------------------------------------------------- |
+| `Default`          | `#[app::init]` calls `AppState::default()` as the baseline |
+| `BorshDeserialize` | Loading state from node storage on every method call       |
+| `BorshSerialize`   | Saving state to node storage after every mutation          |
+
+## Import
+
+```rust
+use calimero_sdk::borsh::{BorshDeserialize, BorshSerialize};
+```
+
+Do not use `borsh` crate directly — import from `calimero_sdk::borsh` to ensure version
+compatibility.

package/skills/calimero-rust-sdk/rules/wasm-constraints.md

@@ -2,16 +2,16 @@
 
 Calimero apps run in a sandboxed WASM environment. The following are **not available**:
 
-| Forbidden | Use instead |
-| --- | --- |
-| `std::thread::spawn` | Not supported — WASM is single-threaded |
+| Forbidden                                     | Use instead                                     |
+| --------------------------------------------- | ----------------------------------------------- |
+| `std::thread::spawn`                          | Not supported — WASM is single-threaded         |
 | `tokio`, `async-std`, `async fn` in app logic | Not supported — all app methods are synchronous |
-| `std::fs`, file I/O | Use `env::private_storage_write/read` |
-| `std::net`, HTTP calls outbound | Not supported in WASM runtime |
-| `println!`, `eprintln!` | Use `calimero_sdk::env::log(&str)` |
-| System time (`std::time::SystemTime`) | Use `calimero_sdk::env::block_timestamp()` |
-| Environment variables | Not accessible from WASM |
-| Random number generation via `rand` | Use `calimero_sdk::env::random_seed()` |
+| `std::fs`, file I/O                           | Use `env::private_storage_write/read`           |
+| `std::net`, HTTP calls outbound               | Not supported in WASM runtime                   |
+| `println!`, `eprintln!`                       | Use `calimero_sdk::env::log(&str)`              |
+| System time (`std::time::SystemTime`)         | Use `calimero_sdk::env::block_timestamp()`      |
+| Environment variables                         | Not accessible from WASM                        |
+| Random number generation via `rand`           | Use `calimero_sdk::env::random_seed()`          |
 
 ## Logging
 
@@ -32,4 +32,6 @@ let ts = env::block_timestamp(); // u64 nanoseconds
 
 ## Why
 
-The `merod` WASM runtime is deterministic by design. Non-deterministic operations (threads, I/O, time, random) would break the CRDT synchronization guarantees — every node must reach the same state given the same sequence of operations.
+The `merod` WASM runtime is deterministic by design. Non-deterministic operations (threads, I/O,
+time, random) would break the CRDT synchronization guarantees — every node must reach the same state
+given the same sequence of operations.

package/skills/calimero-sdk-js/SKILL.md

@@ -0,0 +1,145 @@
+# calimero-sdk-js — Agent Instructions
+
+You are helping a developer **build a Calimero P2P application in TypeScript** using
+`@calimero-network/calimero-sdk-js`. The app compiles to WebAssembly and runs inside the `merod`
+node runtime.
+
+> **NOT this skill** if the developer is connecting a browser/Node.js _frontend_ to a node (that's
+> `calimero-client-js` / `@calimero-network/calimero-client`). This skill is for writing the
+> application logic that _runs on the node_.
+
+## Install
+
+```bash
+pnpm add @calimero-network/calimero-sdk-js
+pnpm add -D @calimero-network/calimero-cli-js typescript
+```
+
+The CLI's `postinstall` hook downloads QuickJS, WASI-SDK, and Binaryen automatically. If you used
+`--ignore-scripts`, re-run with `pnpm install --ignore-scripts=false`.
+
+## Core concepts
+
+| Concept                    | What it is                                                                             |
+| -------------------------- | -------------------------------------------------------------------------------------- |
+| `@State` class             | Persisted data — fields must be CRDT types                                             |
+| `@Logic(StateClass)` class | Entry points callable via JSON-RPC; must extend the state class                        |
+| `@Init` static method      | Seeds the initial state when context is first created                                  |
+| `@View()` method           | Read-only — skips persistence; required for query methods                              |
+| CRDT collection            | Conflict-free type (`Counter`, `UnorderedMap`, etc.) — all state fields must use these |
+
+## Minimal app
+
+```typescript
+import { State, Logic, Init, View } from '@calimero-network/calimero-sdk-js';
+import { UnorderedMap } from '@calimero-network/calimero-sdk-js/collections';
+import * as env from '@calimero-network/calimero-sdk-js/env';
+
+@State
+export class KvState {
+  items: UnorderedMap<string, string> = new UnorderedMap();
+}
+
+@Logic(KvState)
+export class KvLogic extends KvState {
+  @Init
+  static init(): KvState {
+    return new KvState();
+  }
+
+  set(key: string, value: string): void {
+    env.log(`set ${key}`);
+    this.items.set(key, value);
+  }
+
+  @View()
+  get(key: string): string | null {
+    return this.items.get(key) ?? null;
+  }
+}
+```
+
+## CRDT collections quick reference
+
+| Type                | Use case                                | Key ops                                            |
+| ------------------- | --------------------------------------- | -------------------------------------------------- |
+| `Counter`           | Distributed counting (returns `bigint`) | `increment()`, `incrementBy(n)`, `value()`         |
+| `UnorderedMap<K,V>` | Key-value store (LWW per key)           | `set()`, `get()`, `has()`, `remove()`, `entries()` |
+| `UnorderedSet<T>`   | Unique membership (LWW per element)     | `add()`, `has()`, `delete()`, `toArray()`          |
+| `Vector<T>`         | Ordered list                            | `push()`, `get(i)`, `pop()`, `len()`               |
+| `LwwRegister<T>`    | Single value (timestamp LWW)            | `set()`, `get()`                                   |
+
+Nested collections (`Map<K, Set<V>>`) propagate changes automatically — no manual re-serialization.
+
+## Build & deploy
+
+```bash
+# Build to WASM
+npx calimero-sdk build src/index.ts -o build/service.wasm
+
+# Install on node
+meroctl --node-name <NODE> app install \
+  --path build/service.wasm \
+  --context-id <CONTEXT_ID>
+
+# Call a method
+meroctl --node-name <NODE> call \
+  --context-id <CONTEXT_ID> \
+  --method set \
+  --args '{"key":"hello","value":"world"}'
+
+# Call a view
+meroctl --node-name <NODE> call \
+  --context-id <CONTEXT_ID> \
+  --method get \
+  --args '{"key":"hello"}'
+```
+
+## Key rules
+
+- All `@State` fields must be CRDT types — never plain `Map`, `Set`, `Array`, or primitives
+- `@View()` is **required** on every read-only method — omitting it causes unnecessary persistence
+- Use `env.log()` not `console.log()` — `console` is not available in the WASM runtime
+- `Counter.value()` returns `bigint`, not `number`
+- `@Init` must be a static method that returns the state class instance
+- `@Logic(StateClass)` must extend the state class
+- No async, no I/O, no threads in app logic — the WASM runtime is synchronous
+- **Windows: building is not supported natively — use WSL** (QuickJS/WASI-SDK toolchain requires
+  Linux/macOS)
+
+## Events
+
+```typescript
+import { emit } from '@calimero-network/calimero-sdk-js';
+
+// Inside a mutation method:
+emit({ type: 'ItemAdded', key: 'foo', value: 'bar' });
+```
+
+Events are pushed to all context members via WebSocket. Clients subscribe using
+`WsSubscriptionsClient` from `@calimero-network/calimero-client`.
+
+## Private storage (node-local)
+
+```typescript
+import { createPrivateEntry } from '@calimero-network/calimero-sdk-js';
+
+const secret = createPrivateEntry<string>();
+secret.set('my-api-key');
+const val = secret.get();
+```
+
+Private entries are never broadcast to other nodes.
+
+## Related skills
+
+- **`calimero-core`** — runtime concepts (context/app model, JSON-RPC protocol, WebSocket events,
+  CRDT type taxonomy)
+- **`calimero-meroctl`** — full `meroctl` CLI reference for deploying and testing the app
+- **`calimero-client-js`** — connecting a browser/React frontend to the node (not building app
+  logic)
+
+## References
+
+See `references/` for CRDT collections, events, and build pipeline details. See `rules/` for hard
+constraints.

package/skills/calimero-sdk-js/references/build-pipeline.md

@@ -0,0 +1,98 @@
+# Build Pipeline
+
+`@calimero-network/calimero-cli-js` compiles your TypeScript app to a `.wasm` binary.
+
+## Pipeline stages
+
+```text
+TypeScript  →  Rollup  →  QuickJS  →  WASI-SDK  →  Binaryen  →  .wasm
+  Source       Bundle    C bytecode     WASM        Optimized
+```
+
+## Setup
+
+```bash
+# Install SDK and CLI
+pnpm add @calimero-network/calimero-sdk-js
+pnpm add -D @calimero-network/calimero-cli-js typescript
+
+# If postinstall didn't run (--ignore-scripts was set):
+pnpm install --ignore-scripts=false
+# Or manually:
+pnpm --filter @calimero-network/calimero-cli-js run install-deps
+```
+
+## package.json (minimal)
+
+```json
+{
+  "dependencies": {
+    "@calimero-network/calimero-sdk-js": "^0.1.0"
+  },
+  "devDependencies": {
+    "@calimero-network/calimero-cli-js": "^0.1.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "calimero-sdk build src/index.ts -o build/service.wasm"
+  }
+}
+```
+
+## Build command
+
+```bash
+# Build
+npx calimero-sdk build src/index.ts -o build/service.wasm
+
+# Or via npm script
+pnpm build
+```
+
+## Deploy to node
+
+```bash
+# Install the app
+meroctl --node-name <NODE> app install \
+  --path build/service.wasm \
+  --context-id <CONTEXT_ID>
+
+# Create a new context (runs @Init)
+meroctl --node-name <NODE> context create \
+  --app-id <APP_ID>
+
+# Call a mutation
+meroctl --node-name <NODE> call \
+  --context-id <CONTEXT_ID> \
+  --method set \
+  --args '{"key":"hello","value":"world"}'
+
+# Call a view
+meroctl --node-name <NODE> call \
+  --context-id <CONTEXT_ID> \
+  --method get \
+  --args '{"key":"hello"}'
+```
+
+## End-to-end test with Merobox
+
+Each example in the SDK ships a Merobox workflow for multi-node E2E testing:
+
+```bash
+merobox bootstrap run examples/counter/workflows/counter-js.yml --log-level=trace
+```
+
+## Platform support
+
+| Platform           | Supported    |
+| ------------------ | ------------ |
+| macOS (x64, arm64) | Yes          |
+| Linux (x64, arm64) | Yes          |
+| Windows (native)   | No — use WSL |
+
+## Definition of done (before PR)
+
+1. `pnpm lint` passes
+2. `pnpm format:check` passes
+3. `pnpm test` passes
+4. Example app builds: `cd examples/counter && pnpm build`