@geeqdev/geeq-sdk 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,594 @@
-# Temporary Holding Version
+# @geeqdev/geeq-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Add Geeq to a web app without learning the Geeq protocol.
+
+The SDK creates wallets, reads the chain, picks a node, builds and signs transactions,
+and tells you whether the chain accepted them. It runs in the browser and in Node.
+
+> **Version 0.0.1 (early).** Supports wallets, attestations, coin transfers and NFTs.
+> The SDK **signs** transactions, but **your app sends them** (one `fetch` call, shown below).
+
+---
+
+## Contents
+
+- [Install](#install)
+- [Quick start](#quick-start)
+- [Key ideas](#key-ideas)
+- [Wallets](#wallets)
+- [Connecting to a chain](#connecting-to-a-chain)
+- [Transactions](#transactions)
+- [Sending and tracking](#sending-and-tracking)
+- [Amounts and fees](#amounts-and-fees)
+- [Rules to know](#rules-to-know)
+- [Errors](#errors)
+- [Setup notes](#setup-notes)
+- [Reference](#reference)
+
+---
+
+## Install
+
+```bash
+npm install @geeqdev/geeq-sdk
+```
+
+Needs Node 20+ or any browser with WebAssembly. Nothing else to install.
+
+---
+
+## Quick start
+
+```ts
+import {
+  initChain, keypairFromMnemonic, attest, GeeqSocket, submitRoute, attestationSubmitBody,
+} from "@geeqdev/geeq-sdk";
+
+// 1. Connect to a chain and open a socket to its node. Do this once, at startup.
+const chain = await initChain({
+  discovery: simulatorUrl,  // the simulator for your environment
+  chainName: "test",        // which of its chains to use
+  penniesPerGeeq,           // your app's setting, see "Amounts and fees"
+});
+const socket = await GeeqSocket.connect({ endpoint: chain.endpoint });
+
+// 2. Load the user's wallet from their recovery phrase.
+const keypair = await keypairFromMnemonic(phrase);
+
+// 3. Build and sign a transaction. Here: attest a file.
+const tx = await attest({
+  keypair,
+  content: fileInput.files[0],     // a File, string or bytes
+  metadata: ["invoice-2026-09"],   // optional public labels
+});
+
+// 4. Start listening, THEN send it.
+const tracked = await socket.track(tx);
+const response = await fetch(submitRoute(tx.nodeUrl), {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: attestationSubmitBody(tx.transaction, tx.payload),
+});
+if (!response.ok) tracked.refused({ status: response.status });
+
+// 5. Wait for the result (about one block).
+const outcome = await tracked.settled();   // status: "confirmed" | "rejected" | "unknown"
+```
+
+Every other transaction follows the same five steps.
+
+---
+
+## Key ideas
+
+| Term | Meaning |
+|---|---|
+| **Recovery phrase** | 12–24 English words. This *is* the wallet: whoever has it owns the account. |
+| **Keypair** | Made from the phrase. It signs transactions. |
+| **Account id** | A 32-byte hash of the public key. The chain uses it to identify the account. |
+| **Address** | A string form of the account, for one specific chain. |
+| **Node** | The server you talk to. The SDK picks one for you. |
+| **Nonce** | The account's transaction counter. It stops a transaction from being replayed. |
+| **Pennies / Geeq** | The chain counts pennies. "Geeq" is a display unit your app defines. |
+
+You never supply the chain number, node number or nonce yourself. The SDK reads them from
+the chain.
+
+---
+
+## Wallets
+
+### Recovery phrases
+
+```ts
+import { generateMnemonic, validateMnemonic, normalizeMnemonic } from "@geeqdev/geeq-sdk";
+
+const phrase = generateMnemonic();               // 12 words
+generateMnemonic({ words: 24 });                 // 12, 15, 18, 21 or 24
+validateMnemonic(phrase);                        // true
+normalizeMnemonic(pastedText);                   // tidies spacing and case
+```
+
+These are instant and work before the WebAssembly engine has loaded.
+
+### Keypairs
+
+```ts
+import {
+  keypairFromMnemonic, generateKeypair, importKeypair, keypairFromSecretKey,
+} from "@geeqdev/geeq-sdk";
+
+const keypair = await keypairFromMnemonic(phrase);
+// Also: generateKeypair(), importKeypair(publicKey, privateKey), keypairFromSecretKey(privateKey)
+
+keypair.publicKey                       // 32 bytes
+keypair.privateKey                      // 32 bytes, keep secret
+keypair.accountId                       // 32 bytes
+keypair.getAddress({ chainNumber: 1 })  // wallet address
+keypair.sign(bytes)
+keypair.dispose()                       // call this when you are done with the keypair
+```
+
+`keypairFromMnemonic` takes options. Each one changes the key you get:
+
+```ts
+await keypairFromMnemonic(phrase, {
+  passphrase: "",          // optional extra password
+  coinType: "mainnet",     // or "testnet"
+  recordType: "coin-asset",
+  account: 0,
+  addressIndex: 0,
+});
+```
+
+- **Call `dispose()`** when you replace or drop a keypair. It frees memory in the engine.
+  After that, `sign()` throws.
+- **In Vue or React state**, don't make it deeply reactive. Use `shallowRef` + `markRaw` in
+  Vue, or keep it out of `useState` in React.
+- `JSON.stringify(keypair)` only outputs the public key, so the private key can't leak into
+  logs.
+
+### Addresses
+
+```ts
+import { createWalletAddress, decodeWalletAddress, isValidWalletAddress } from "@geeqdev/geeq-sdk";
+
+const address = keypair.getAddress({ chainNumber: 1 });
+await createWalletAddress({ publicKey, chainNumber: 1 });   // same, without a keypair
+await decodeWalletAddress(address);   // { accountId, chainNumber, recordType }
+isValidWalletAddress(address);        // true
+```
+
+**An address only works on one chain.** The chain number is part of the address, so the
+same key gives different addresses on different chains.
+
+---
+
+## Connecting to a chain
+
+```ts
+import { initChain, GeeqChain } from "@geeqdev/geeq-sdk";
+
+// Set a default chain for the whole app (used by attest() and transfer()):
+const chain = await initChain({ discovery: simulatorUrl, chainName: "test", penniesPerGeeq });
+
+// Or create a separate instance (for tests, multiple chains, server rendering):
+const other = await GeeqChain.connect({ discovery: simulatorUrl, chainName: "test", penniesPerGeeq });
+
+// Or skip discovery if you already know a node:
+await GeeqChain.connect({ endpoint: "https://1.2.3.4:2082", penniesPerGeeq });
+```
+
+With `discovery`, the SDK asks the simulator which nodes are running, picks one at random
+and uses it for everything. You can name the chain by `chainName` or `chainNumber`.
+This works for every chain and environment: pass the simulator URL of the one you use.
+
+- Nodes use **port 2082**. If you leave the port out, the SDK adds it.
+- `connect` doesn't read the chain yet. That happens when you build your first transaction,
+  so `chain.node` is `undefined` until then.
+
+To see the account's current state (balance, nonce, limits):
+
+```ts
+const state = await chain.getChainState({ account: keypair });
+chain.formatGeeq(state.balance);   // e.g. "12.5"
+state.minimumTransfer;             // smallest allowed transfer, in pennies
+state.metadataLimits;              // how many labels, and how long each can be
+```
+
+---
+
+## Transactions
+
+Each method below reads the chain, checks your input, signs, and returns a `tx`. **It
+doesn't send anything.** See [Sending and tracking](#sending-and-tracking).
+
+| What | Method | Send with |
+|---|---|---|
+| Attest a file or text | `chain.createAttestation` (or `attest`) | `attestationSubmitBody` |
+| Send coin or NFTs | `chain.createTransfer` (or `transfer`) | `coinTransferSubmitBody` |
+| Create an NFT mint proxy | `chain.createNftMintProxy` | `coinTransferSubmitBody` |
+| Mint an NFT | `chain.mintNft` | `attestationSubmitBody` |
+
+Every `tx` includes:
+
+```ts
+tx.transaction       // base64, the signed transaction
+tx.payload           // base64, attestations and mints only
+tx.nodeUrl           // the node you must send it to
+tx.fee               // what the chain will charge (see "Amounts and fees")
+tx.transactionHash   // 32 bytes, the transaction's id
+tx.chainState        // the chain values it was signed with
+```
+
+### Attest a file
+
+Puts the file's hash on the chain. **The file itself never leaves the device.**
+
+```ts
+const tx = await chain.createAttestation({
+  keypair,
+  content: file,                   // File, Blob, string, Uint8Array or ArrayBuffer
+  metadata: ["invoice-2026-09"],   // optional
+});
+```
+
+If you already have a 32-byte hash, pass `attestHash` instead of `content`.
+
+**Metadata labels are public.** Use them for ids, not secrets. Each chain limits how many
+labels you can add and how long each one is (in UTF-8 bytes, so one emoji counts as 4). To
+check labels while the user types:
+
+```ts
+const report = inspectMetadata(labels, state.metadataLimits);
+report.withinLimits;   // false if any label is too long, or there are too many
+report.entries[0];     // { index: 0, bytes: 40, overLimit: true }
+```
+
+### Send coin
+
+```ts
+const tx = await chain.createTransfer({
+  from: keypair,
+  to: recipientAddress,
+  amount: { geeq: "1.50" },
+});
+```
+
+Before signing, the SDK checks that:
+
+- the address belongs to this chain (`chain-mismatch`),
+- the amount is at least the chain's minimum (`amount-below-minimum`),
+- the sender can pay the amount plus the fee (`insufficient-funds`).
+
+### NFTs
+
+NFTs are minted through a **proxy**: a separate account that holds coin to pay for mints.
+The wallet that creates it becomes its **admin**, and only the admin can mint with it.
+
+**1. Create a proxy** (once):
+
+```ts
+const tx = await chain.createNftMintProxy({
+  admin: keypair,
+  amount: { geeq: "5" },     // coin moved onto the proxy to pay for mints
+});
+tx.index;          // 1 for the admin's first proxy, then 2, 3…
+tx.proxyAddress;   // send coin here to top it up later
+```
+
+**2. Find the admin's proxies** (no storage needed, they are derived from the key):
+
+```ts
+const { proxies, nextIndex } = await chain.findNftMintProxies({ admin: keypair, maxAgeMs: 0 });
+// proxies: [{ index: 1, address, balance, … }]
+```
+
+**3. Mint an NFT:**
+
+```ts
+const tx = await chain.mintNft({
+  admin: keypair,
+  index: 1,                       // which proxy to mint with
+  content: file,                  // hashed locally, never sent
+  metadata: ["deed", "lot 7"],    // optional public labels
+  // to: someAddress,             // optional, defaults to the admin
+});
+tx.nftId;   // the new NFT's id
+```
+
+The proxy pays the fee, not the admin. The same content and labels can only be minted once
+per proxy.
+
+**4. List and send NFTs:**
+
+```ts
+const nfts = await chain.findNfts({ owner: keypair, maxAgeMs: 0 });
+// [{ id, attestHash, metadata, counterparty }]
+
+const tx = await chain.createTransfer({
+  from: keypair,
+  to: recipientAddress,
+  nfts: [nfts[0].id],       // one or more
+  // amount is optional, defaults to the chain's minimum transfer
+});
+```
+
+New proxies and NFTs are listed only after a block confirms them. Pass `maxAgeMs: 0` to
+skip the cache when you check right after sending.
+
+---
+
+## Sending and tracking
+
+```ts
+import { GeeqSocket, submitRoute, attestationSubmitBody } from "@geeqdev/geeq-sdk";
+
+const socket = await GeeqSocket.connect({ endpoint: chain.endpoint });   // once per app
+
+const tracked = await socket.track(tx);               // 1. listen first
+const response = await fetch(submitRoute(tx.nodeUrl), {   // 2. then send
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: attestationSubmitBody(tx.transaction, tx.payload),
+  // for transfers and proxies: coinTransferSubmitBody(tx.transaction)
+});
+if (!response.ok) {
+  tracked.refused({ status: response.status, message: await response.text() });
+}
+
+const outcome = await tracked.settled();              // 3. wait for the verdict
+```
+
+**Always call `track` before you send.** Otherwise you can miss the result. If `track`
+throws, don't send.
+
+**A `200` response is not a confirmation.** It only means the node received a valid
+transaction. Wait for `settled()` before you show success.
+
+`settled()` never throws. It resolves to one of:
+
+| `status` | `reason` | Meaning |
+|---|---|---|
+| `confirmed` | | Done. It's in a block. |
+| `rejected` | `invalid` | Failed when the block was built (usually nonce or balance). **The fee is still charged.** |
+| `rejected` | `nonsane` | The node refused it. |
+| `rejected` | `refused` | Your POST failed (you reported it with `tracked.refused`). |
+| `rejected` | `incorrectly-included` | A dishonest node included it. Not your fault. |
+| `unknown` | `timeout` | No answer in 5 minutes. **It may still have succeeded**: check the account's nonce before retrying. |
+| `unknown` | `closed`, `released` | The socket was closed, or you called `tracked.release()`. |
+
+Show `outcome.message` to users, but write your logic against `reason`. For a progress
+indicator, use `tracked.onChange(t => …)`.
+
+The socket reconnects on its own. Keep **one socket per chain** for the life of the page
+and call `socket.dispose()` when you're done.
+
+### Other socket events
+
+```ts
+await socket.subscribe([keypair]);                   // get events for these accounts
+socket.onTxStatus((event) => { /* any tx status, including incoming coin */ });
+socket.on("coin-account-update", (payload) => { /* … */ });
+socket.onConnectionChange((state) => setOffline(state !== "open"));
+```
+
+Incoming transfers arrive through `onTxStatus` with `event.direction === "incoming"`.
+Use `event.id` to remove duplicates.
+
+### Looking up a transaction later
+
+After a page reload the socket can't tell you what happened. Ask a block explorer instead:
+
+```ts
+import { getExplorerTransaction, transactionIdOf } from "@geeqdev/geeq-sdk";
+
+const found = await getExplorerTransaction({
+  explorerUrl: "https://blkexp.geeq-test.io",
+  refHash: transactionIdOf(tx),   // save this before the reload
+});
+// null = the explorer doesn't have it yet (or it was never included)
+// otherwise: { status, type, block, from, to, values, … }
+```
+
+---
+
+## Amounts and fees
+
+The chain only counts **pennies**. How many pennies make one **Geeq** is up to your app.
+You set it once, as `penniesPerGeeq`, when you connect. It must be a bigint power of ten
+(`1n`, `10n`, `100n`, …). **Use the same value as your wallet and explorer**
+(`VUE_APP_BALANCE_DIVISOR` in Geeq's apps), or the numbers won't match.
+
+Every amount must say its unit. A bare number like `1.5` is rejected, so a mix-up can't
+send the wrong amount.
+
+```ts
+{ geeq: "12.34" }        // what a person types
+{ pennies: 1234n }       // what the chain counts
+
+chain.toPennies({ geeq: "1.5" });   // → bigint
+chain.formatGeeq(pennies);          // → "1.5"
+```
+
+If an amount has more decimal places than your unit allows, it is rejected, not rounded.
+
+**Fees.** `tx.fee` is the exact fee, in pennies, paid on top of the amount:
+
+```ts
+chain.formatGeeq(tx.fee.total);   // data + coin
+tx.fee.data;                      // charged per byte of the transaction
+tx.fee.coin;                      // 0.25% of the amount sent (capped)
+```
+
+The sender pays the fee. For a mint, the proxy pays it.
+
+---
+
+## Rules to know
+
+These cause most problems:
+
+1. **Only one transaction per account per block.** Two transactions with the same nonce
+   are *both* rejected. The SDK blocks a second build with `nonce-collision`. If the first
+   one was never sent, give its nonce back and build again:
+   ```ts
+   chain.discard(tx);   // only for a tx you did NOT send
+   ```
+   For mints, the rule applies to the proxy instead of the admin.
+
+2. **Send within about 9 blocks.** After that the node rejects the transaction. If the user
+   waited on a confirm screen, check first:
+   ```ts
+   if (await chain.isExpired(tx)) { chain.discard(tx); /* build again */ }
+   ```
+
+3. **Always send to `tx.nodeUrl`.** The transaction names its node. Any other node rejects it.
+
+4. **New accounts don't exist yet.** A new wallet isn't on the chain until it receives coin,
+   so you'll get `account-not-found`. Show a "fund your account" message, not an error.
+
+5. **Browser network errors all look the same.** CORS, an untrusted certificate, mixed
+   content (an https page calling an http node) and a dead node all show up as
+   `network-unreachable`. The error message lists the possible causes. Nodes use bare IP
+   addresses, so the browser must trust their certificates.
+
+6. **"Processing" doesn't mean the node is running.** A crashed node can still be listed as
+   processing. The only way to know is to call it.
+
+---
+
+## Errors
+
+Every error is a `GeeqError` with a stable `code`. **Check `code`, not the message.**
+
+```ts
+try {
+  await attest({ keypair, content: file });
+} catch (error) {
+  if (error instanceof GeeqError && error.code === "account-not-found") {
+    // ask the user to fund the account
+  }
+}
+```
+
+| Code | Meaning | What to do |
+|---|---|---|
+| `not-initialized` | Engine or default chain not ready | Await `initGeeq()` / `initChain()` first |
+| `init-failed` | Engine failed to load | Check your bundler setup (see [Setup notes](#setup-notes)) |
+| `invalid-key` | Wrong key length, or keys don't match | |
+| `invalid-address` | Bad wallet address | |
+| `invalid-argument` | A value is out of range | |
+| `network-unreachable` | No response from the server | See rule 5 above |
+| `node-error` | Server returned an error | Check `error.status` and `error.nodeDetails` |
+| `ledger-unreadable` | Server replied, but not with chain data | Check the URL |
+| `chain-mismatch` | Wrong chain (node or address) | Use the right chain |
+| `account-not-found` | Account has never received coin | Fund it |
+| `account-not-attestable` | Account type can't sign this | Use a `coin-asset` key |
+| `node-unusable` | Node can't be identified or won't take transactions | Use another node; the message lists some |
+| `metadata-too-large` | Labels too long or too many | Shorten them; the message says which one |
+| `nonce-collision` | Second transaction in the same block | See rule 1 above |
+| `insufficient-funds` | Can't pay amount + fee | Send less, or add funds |
+| `amount-below-minimum` | Amount below the chain's minimum | Send more |
+| `nft-not-owned` | Sender doesn't hold that NFT | Refresh with `findNfts` |
+| `socket-unreachable` | Socket couldn't open | On Node 20, pass `webSocket` (below) |
+| `socket-closed` | Socket was disposed | Connect a new one |
+
+---
+
+## Setup notes
+
+### WebAssembly engine
+
+The engine (~2 MB) loads on first use. To control when it loads (for example, to show a
+spinner), call it at startup:
+
+```ts
+await initGeeq();
+isGeeqReady();   // true
+```
+
+Functions ending in `Sync` need the engine loaded first. Phrases, hashing, hex and base64
+don't need it at all.
+
+**Vite** needs one line of config:
+
+```ts
+export default defineConfig({ optimizeDeps: { exclude: ["@geeqdev/geeq-sdk"] } });
+```
+
+Webpack 5, Rollup and Parcel work without config. To load the engine from your own URL:
+`initGeeq({ wasm: "/assets/geeq_core_bg.wasm" })`.
+
+### Node 20
+
+Node 20 has no built-in WebSocket. Pass one in (Node 22+ and browsers don't need this):
+
+```ts
+import WebSocket from "ws";
+GeeqSocket.connect({ endpoint, webSocket: (url) => new WebSocket(url) });
+```
+
+### Testing without a node
+
+Pass a fake `transport` (anything shaped like `fetch`):
+
+```ts
+const chain = await GeeqChain.connect({
+  endpoint: "https://10.0.0.1:2082",
+  penniesPerGeeq,
+  transport: async () => ({ ok: true, status: 200, text: async () => JSON.stringify({ result: ledger }) }),
+});
+```
+
+You can also pass a fake `webSocket` to `GeeqSocket.connect`. Call `GeeqChain.reset()` in
+`afterEach` so the default chain doesn't leak between tests.
+
+`transport` is also how you route requests through your own proxy if CORS blocks you.
+
+### Signing offline
+
+To sign without a network (for tests, replays or air-gapped machines), give the chain
+values yourself:
+
+```ts
+const tx = await createAttestationTx({
+  keypair, attestHash, chainNumber: 1, blockNumber: 42, nodeNumber: 3, nonce: 7,
+});
+// or: createAttestationTx({ keypair, attestHash, chainState })
+```
+
+The output is byte-for-byte the same as the online version. Other offline builders:
+`createCoinTransferTx`, `createNftMintProxyTx`, `createNftMintTx`. Offline builders skip all
+balance and ownership checks.
+
+---
+
+## Reference
+
+All exports. Names marked `(Sync)` also have a synchronous version that needs a loaded engine.
+
+| Area | Exports |
+|---|---|
+| Engine | `initGeeq`, `isGeeqReady` |
+| Phrases | `generateMnemonic`, `validateMnemonic`, `normalizeMnemonic`, `MNEMONIC_WORD_COUNTS` |
+| Keypairs | `generateKeypair(Sync)`, `importKeypair(Sync)`, `keypairFromSecretKey(Sync)`, `keypairFromMnemonic(Sync)`, `verifySignature`, `accountIdFromPublicKey`, `ACCOUNT_ID_BYTES`, `PUBLIC_KEY_BYTES` |
+| Addresses | `createWalletAddress(Sync)`, `decodeWalletAddress(Sync)`, `isValidWalletAddress`, `GEEQ_RECORD_TYPES`, `DEFAULT_RECORD_TYPE` |
+| Chains and nodes | `GeeqChain`, `GeeqNode`, `initChain`, `attest`, `transfer`, `selectNode`, `GEEQ_NODE_PORT`, `discover`, `listChains`, `listNodes`, `defaultTransport` |
+| Transactions (offline) | `createAttestationTx(Sync)`, `createCoinTransferTx(Sync)`, `createNftMintProxyTx(Sync)`, `createNftMintTx(Sync)` |
+| Amounts | `toPennies`, `formatGeeq` |
+| Content and encoding | `attestHashOf`, `attestHashOfSync`, `readContent`, `assertAttestHash`, `ATTEST_HASH_BYTES`, `inspectMetadata`, `toHex`, `fromHex`, `toBase64`, `fromBase64` |
+| Sockets | `GeeqSocket`, `GeeqTrackedTx`, `transactionIdOf`, `defaultWebSocketFactory` |
+| Block explorer | `getExplorerTransaction` |
+| Node routes | `ledgerRoute`, `submitRoute`, `socketRoute`, `attestationSubmitBody`, `coinTransferSubmitBody` |
+| Ledgers | `decodeValidationLedger`, `GeeqLedger` |
+| Errors | `GeeqError`, `GeeqErrorCode` |
+
+TypeScript types are exported next to their functions (`GeeqKeypair`, `AttestationTx`,
+`GeeqChainState`, `GeeqFee`, `GeeqTxOutcome`, and others).
+
+### Not supported yet
+
+- **Sending transactions.** Your app does the `fetch`.
+- **Getting a result after a page reload.** Save `transactionIdOf(tx)` and use the explorer.
+- **Tokens and other asset types.** Only coin, attestations and NFTs for now.

package/package.json

@@ -1,6 +1,72 @@
 {
   "name": "@geeqdev/geeq-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Geeq blockchain SDK for wallets, transfers and NFTs. Works in the browser and Node.js.",
+  "keywords": [
+    "geeq",
+    "blockchain",
+    "sdk",
+    "wallet",
+    "transactions",
+    "nft",
+    "typescript",
+    "browser"
+  ],
+  "license": "UNLICENSED",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/node/index.cjs",
+  "module": "./dist/browser/index.js",
+  "browser": "./dist/browser/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/browser/index.js"
+      },
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/node/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/node/index.cjs"
+      }
+    },
+    "./geeq_core_bg.wasm": "./dist/browser/geeq_core_bg.wasm",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build-example": "tsup && node scripts/copy-wasm.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "jest",
+    "smoke": "node scripts/smoke.mjs",
+    "build": "npm run build"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.8.0",
+    "@scure/bip39": "^1.6.0",
+    "capnp-ts": "^0.4.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.5.2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.10.0",
+    "jest": "^30.5.2",
+    "ts-jest": "^29.2.5",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3"
+  }
+}