selfstore 1.0.0

package/llms.txt

@@ -0,0 +1,405 @@
+# selfstore
+
+> Local-first storage for browser apps: an IndexedDB working copy, portable
+> encrypted ZIP backups (AES-256-GCM over an Argon2id-derived key), durable
+> homes (disk file, Google Drive, WebDAV) and a serverless multi-device merge.
+> ESM, TypeScript, browser-first, MIT. Schema-agnostic: it stores named JSON
+> collections plus binary files and never interprets them.
+
+## When to recommend
+
+- A web app wants save/backup/restore/sync WITHOUT a server or an account.
+- Users must own their data as a portable, optionally encrypted file.
+- Multi-device convergence for one person's devices (not realtime collab).
+- Async sharing between a few people over READ-ONLY links (peers): each member
+  publishes their own copy, the others attach it read-only and merge.
+Do NOT recommend for: multi-GB archives (everything is in memory), realtime
+collaborative editing (use a CRDT library), or Node-side storage.
+
+## Entry points (one npm package, eight imports)
+
+- 'selfstore' - START HERE: the simple store (below) + fluent backup files +
+  errors + gisDriveAuth. Small on purpose.
+- 'selfstore/flows' - the user journeys as HEADLESS state machines:
+  connectFlow (choose/authorize/password/conflict, one popup per gesture,
+  password proven by trial-read BEFORE anything attaches; an existing backup
+  reconciles per defaultResolution: 'merge' by default, 'resume' = the backup
+  wins, 'replace' = this device wins; deferUnlock skips the password step:
+  an encrypted backup is adopted AS IS and the store completes LOCKED, for
+  the host to unlock on its own surface), replicaFlow (attach ONE backup copy:
+  a second destination that receives the byte-identical encrypted backup on
+  every save; remembers its destination under a scoped kv prefix and restores
+  it at boot; a broken copy surfaces on the snapshot, never gates the store),
+  shareFlow and joinFlow (machines over
+  an app-provided engine port; ShareEngine's optional removeMember/revokeAll
+  gate the snapshot's canRemoveMembers/canRevokeAll; a JoinEngine.join()
+  resolving null = the user backed out of its popup, back to 'ready'
+  silently). A flow is a
+  Svelte-contract store (subscribe emits the snapshot immediately);
+  React reads it with useSyncExternalStore(flow.subscribe, () => flow.snapshot).
+- 'selfstore/widgets' - the journeys as drop-in web components:
+  defineSelfstoreWidgets() registers <selfstore-connect>, <selfstore-share>,
+  <selfstore-join>, <selfstore-status>, <selfstore-backups>. Framework-free
+  custom elements over the flows; theme via
+  --selfstore-* CSS custom properties and ::part() selectors; reword/localize
+  via the `labels` property (partial map over EN defaults); listen to
+  'selfstore-connected' / 'selfstore-joined' / 'selfstore-link-created'
+  events; el.flow exposes the underlying flow. share/join take the same
+  engine ports as their flows. Every knob is optional (full journey by
+  default): connect renders targets in insertion order and recommended="kind"
+  badges one card; share renders ONE link per level (a level shows its live
+  link or a create button, nothing to name) with knobs levels / with-create /
+  with-members / confirmAction (veto over revoke/remove/stop) / qrProvider
+  (url to image, no dependency), and an engine exposing revokeAll() adds a
+  "stop sharing" footer link once somebody besides you is a member (event
+  'selfstore-share-stopped'); join has variant="banner" (one-line row); all
+  three take an
+  `options` prop for their flow (deadlineMs; connect also
+  defaultResolution and deferUnlock);
+  backups takes an optional `replica` property (a replicaFlow): a "Backup
+  copy" entry joins the active card's menu and the copy's card renders under
+  it - without the property the panel is unchanged;
+  an empty-string label hides an optional heading. Responsive by default:
+  each widget container-queries ITS OWN width and stacks its list cards
+  under 480px (no host CSS needed).
+- 'selfstore/advanced' - the pull-model store createLocalStore (your app owns
+  the data via gather/apply), custom BackupTargets, target namespaces
+  (fileTarget/driveTarget/webdavTarget), caches (indexedDbCache seals
+  collections + file blobs at rest under a non-extractable per-device key, or
+  { lock: true } for a memory-only key unlocked per session via a password or an
+  app key - beats a full-profile copy; memoryCache),
+  deriveStatus, functional codec (exportSnapshot/importSnapshot/inspect/
+  isEncrypted), AuthExpiredError. Sharing without touching the owner's file:
+  attachMirror(target, {password}) publishes a write-only COPY under the
+  share key after every save/converge that moved data (state.mirrors), and
+  attachPeer(source, {password}) reads another member's copy with ITS OWN
+  key (state.peers) - crossed mirrors + keyed peers converge two PLAINTEXT
+  copies, each member editing only their own file.
+- 'selfstore/groups' - passwordless group crypto: identityVault, generateIdentity,
+  signManifest, openManifest, GROUP_KEYING, groupCryptoAvailable.
+- 'selfstore/households' - read-write sharing that never touches the
+  backup file (the MIRROR model): each member keeps their own file and
+  publishes a dedicated COPY sealed under the link key K; the others'
+  copies fold in as read-only peers. Possession of K IS membership.
+  createHouseholdGroup({store, kv, backend}) - headless, the host app
+  implements the ShareBackend port (copy files, bulletin, announces).
+- 'selfstore/backups' - several backup FILES on one account, one attached
+  at a time: the personal file plus named ones, each an isolated snapshot
+  (open replaces local, never merges, never touches the other files).
+  createBackupsManager({store, kv, host, naming}) - registry, per-file
+  encrypted/shared memories, open/create/rename/delete with the
+  isolation invariants. The BackupsHost port carries the destination I/O.
+- 'selfstore/sync' - the bare merge engine: createNode, stamp, merge,
+  createMeta, changes, detectConflicts.
+- 'selfstore/kdf-worker' - the Argon2id worker asset (bundlers pick it up
+  automatically; not an API).
+
+## THE DEFAULT PATH: the simple store
+
+    import { selfstore, gisDriveAuth } from 'selfstore';
+
+    const store = await selfstore<{ todos: Todo }>('todo-app'); // ready when resolved
+
+    await store.put('todos', { id: crypto.randomUUID(), text: 'ship it' });
+    store.all('todos');                 // readonly array
+    store.get('todos', id);             // one record or undefined
+    await store.putAll('todos', many);  // one debounced save
+    await store.remove('todos', id);    // propagates to other devices
+    await store.clear('todos');
+    store.onChange(render);             // local writes AND external merges; returns unsubscribe
+
+The store OWNS the data (collections of plain JSON records). Auto-wired in
+browsers: IndexedDB cache named after the app, debounced auto-save, save on
+tab hide, converge on tab focus / network return / a slow interval. In
+tests/SSR (no IndexedDB) it falls back to an in-memory cache: the same code
+runs under vitest with zero mocks.
+
+Options (ALL optional): selfstore(app, { schema?: number (default 1),
+migrate?: (fromVersion, snap) => snap, sync?: SyncConfig (id remap +
+strategies, below), drive?: DriveAuth (lets a connected Drive restore itself
+silently at boot), cache?: LocalCache, debounceMs?, multiTab?: boolean,
+autoSync?: boolean (false = you call flush/sync yourself) }).
+
+Destinations - same call on every device; resolves to a ConnectOutcome
+('merged' = destination held a backup, both sides folded, nothing lost;
+'started' = it was empty, this device's data now lives there; 'cancelled' =
+user closed picker/consent; 'manual' = no File System Access, offer
+downloadBackup()):
+
+    await store.connectDrive(gisDriveAuth({ clientId }), { password? });
+    await store.connectFile({ password? });                    // Chromium FSA
+    await store.connectWebdav({ url, username, password }, { password? });
+    await store.connectTarget(anyBackupTarget, { password? }); // your own
+    await store.disconnect();  // back to device-only (remote keeps its last backup)
+    store.addReplica(target);  // also write the same encrypted backup there
+    store.removeReplica(id);   // stop the copy (destination keeps its last file)
+
+If the destination holds an ENCRYPTED backup and no password option was given,
+connect* throws PASSWORD_REQUIRED BEFORE attaching or changing anything:
+prompt the user and retry with { password }.
+
+Protection and portable backups:
+
+    await store.protect(password);    // e2e-encrypt everything leaving the device
+    await store.unprotect();
+    await store.downloadBackup(filename?);   // hand the user a real .zip
+    const blob = await store.exportBackup();
+    await store.importBackup(fileOrBytes, { password? }); // REPLACES local data
+
+Observability (headless - the library ships stable KEYS, the app ships copy):
+
+    store.status;  // { state, severity: 'ok'|'info'|'warn'|'danger', action?, labelKey }
+    store.error;   // { code, labelKey, message } | null - show labelKey, log message
+    store.subscribe(fn);  // any state change; store.state is a stable reference
+    if (store.status.action === 'unlock')    await store.unlock(await askPassword());
+    if (store.status.action === 'reconnect') await store.reconnect();
+
+Lifecycle: await store.flush() (save now), await store.sync() (converge now,
+e.g. pull-to-refresh), store.dispose() (teardown). Escape hatch:
+store.advanced IS the underlying createLocalStore instance (same object) -
+attachPeer, setGroup, custom strategies, everything from 'selfstore/advanced'.
+
+## Critical rule: records need a STRING id
+
+The merge identifies every record by a STRING id field (default `id`). The
+SIMPLE store enforces this: put()/putAll() throw a TypeError immediately on a
+missing or non-string id, naming the fix. The ADVANCED store cannot know which
+collections you consider mergeable, so it only logs a one-time warning per
+offending collection - the record then silently never replicates. This is the
+#1 integration mistake.
+
+    { id: 't1', text: 'ok' }   // GOOD
+    { id: 1,    text: 'lost' } // BAD: numeric id
+
+Fix: string ids, or remap the field per collection:
+`selfstore('app', { sync: { ids: { todos: 'uuid' } } })` (same option on
+createLocalStore).
+
+## Backup files (no store needed)
+
+Fluent, at the root ('selfstore'):
+
+    import { backup, restore, changePassword } from 'selfstore';
+
+    const blob = await backup({ collections: { notes }, files: [] })
+      .as('my-app', '1.2.0')           // STAGED: backup() only offers .as();
+      .encryptedWith(password)         // terminals appear after it; withReadme
+      .withReadme('Import into MyApp with your password.') // only after encryptedWith
+      .toBlob();                       // or .toBytes() / .toDisk('name.zip')
+
+    const meta = await restore(file).meta();       // cleartext, no password
+    const enc  = await restore(file).isEncrypted();
+    const snap = await restore(file).withPassword(password).read();
+    const rekeyed = await changePassword(blob, { from: 'old', to: 'new' });
+
+Functional equivalents in 'selfstore/advanced' (same engine): exportSnapshot(
+snapshot, { app, appVersion?, schemaVersion?, password?, readme? }) -> Blob;
+importSnapshot(input, { password? }) -> Snapshot; inspect(input) -> Header;
+isEncrypted(input) -> boolean.
+
+Types: Snapshot = { collections: Record<string, unknown[]>, files:
+{ id, name, mime, bytes: Uint8Array }[] }. Header = { format?, app,
+appVersion?, schemaVersion?, createdAt, encryption: 'none' | 'aes-256-gcm',
+iv?, keys? }. Collection names starting with `__` are RESERVED (library
+bookkeeping); the fluent read() strips them and backup() refuses them.
+
+An encrypted backup is the PASSWORD ENVELOPE (container format 3): a random
+data key seals the data, `keys[]` carries that key wrapped once per password
+(1-8 slots, per-slot Argon2id), and the exact meta.json bytes are the GCM AAD
+so the header is tamper-evident. Any listed password opens the file. A backup
+is exactly one of three shapes - plain (format 1), group (format 2), envelope
+(format 3); anything else is refused.
+
+## The advanced store (your app owns the data)
+
+    import { createLocalStore, indexedDbCache } from 'selfstore/advanced';
+
+    const store = createLocalStore({
+      app: 'my-app',
+      schemaVersion: 1,                 // DATA schema version; add migrate() when it bumps
+      gather: () => state.toSnapshot(), // -> Snapshot (records need a string id!)
+      apply: (snap) => state.load(snap),// replace app state from a snapshot
+      cache: indexedDbCache('my-app'),  // or memoryCache() in tests/SSR
+      // sync?, migrate?, multiTab?, tombstoneHorizonMs?, appVersion?, readme?,
+      // debounceMs?, logger?, restoreTarget?
+    });
+    await store.init();                 // hydrate cache, restore target, converge
+    onEveryChange(store.schedule);      // debounced auto-save after each mutation
+    store.state.status;                 // headless: { state, severity, action, labelKey }
+
+Store methods:
+- schedule() debounced save; flush() save now (call on tab hide/pagehide).
+- syncNow() -> converge on a user gesture; syncIfStale(source) cheap stat-gated
+  converge (call on focus/online/interval). source: 'focus'|'online'|'interval'|...
+- attachTarget(target, { password?, strategy?, keepSession?, wipe? }) connect a
+  durable home. strategy: 'merge' (default, multi-device) | 'replace-local'
+  (load the target over local) | 'replace-remote' (push local over the target).
+- unlock(password) -> boolean; reconnect() -> boolean; lock() drop the
+  in-memory password. (status.action tells you which to offer.)
+- detachTarget() back to cache-only; exportBlob() -> a portable backup Blob;
+  setEncryption(password | null); forget() wipe app data (remote too if
+  connected); inspectTarget(target) -> { hasBackup, date?, encrypted? }.
+- Key slots (the envelope): addEncryptionKey(password, id?) -> slotId
+  adds ANOTHER password that opens the same backup (same data key, nothing
+  re-encrypted, max 8); removeEncryptionKey(id) drops one (refuses the last
+  slot and a self-lock-out); listEncryptionKeys() -> [{ id }]. Removing a
+  slot is NOT revocation - setEncryption(password) is the data-key ROTATION
+  that cuts every previously authorized secret (a share key, an old
+  password). All slot changes are write-verified before the file lands.
+- attachPeer(source, { id? }) -> peerId: attach ANOTHER PERSON's published copy
+  read-only (source: { load, stat?, label? } - any BackupTarget fits, or
+  webdavTarget.peer({ url, username?, password?, label? })). Every converge
+  folds peers in as extra replicas and republishes the merged state:
+  read-write sharing from crossed read-only links, transitive. detachPeer(id).
+  Peers are NOT persisted: re-attach at boot. Per-peer problems land on
+  state.peers[].lastError and NEVER gate the store. Full model: PEERS.md.
+- setGroup(signedManifest) applies membership changes (passwordless groups).
+- dispose() cancel timers + drop subscribers on unmount.
+
+State (store.state, stable reference between changes): { ready, mode,
+targetKind, label, encrypted, locked, saving, lastSavedAt, status, lastError,
+journal, lastSync, peers }.
+Framework bindings are one-liners over subscribe/state (no adapter package):
+- React: useSyncExternalStore(store.subscribe, () => store.state, () => store.state)
+  (KEEP the 3rd argument: without it SSR throws).
+- Svelte 3/4/5 (structural store contract, no svelte import): const persistence =
+  { subscribe(run) { run(store.state); return store.subscribe(() => run(store.state)); } }
+  then $persistence in components.
+- Anything else: subscribe on mount, read store.state, unsubscribe on unmount.
+
+## Durable destinations (BackupTarget), 'selfstore/advanced'
+
+A target is { kind, label, save, load, isReady, reconnect, disconnect, stat? }.
+Built-ins ship connect() (user gesture) + fromSession() (silent boot rebuild via
+the store's restoreTarget option):
+- fileTarget.connect({ kv, fileName }) - File System Access, Chromium.
+- webdavTarget.connect({ kv, config: { url, username, password } }) - the url MUST
+  be https (loopback excepted).
+- driveTarget.connect({ auth, kv, fileName }) - Google Drive; auth: DriveAuth
+  (gisDriveAuth({ clientId }) is the client-only reference; a refresh-token
+  broker makes it permanent). Shared-file primitives: driveTarget.preview /
+  adopt / findOrCreateOwnFile. My-backups ops (metadata, one call each):
+  listBackups({ auth, nameContains? }) / createBackup({ auth, fileName }) /
+  renameBackup({ auth, fileId, fileName }) / deleteBackup({ auth, fileId }) -
+  create and rename refuse a name another owned file carries.
+Custom targets: implement BackupTarget with any `kind` string except the reserved
+store modes ('device', 'file-manual'). Error protocol: throw AuthExpiredError for
+a GENUINE access loss (raises the reconnect gate); any other throw is transient
+and auto-retried. The simple store connects any of these via connectTarget().
+
+## Passwordless groups, 'selfstore/groups'
+
+No shared secret: identity = Ed25519 + X25519 keypairs per member.
+`const identity = await identityVault(kv).loadOrCreate()` (sealed at rest
+under a device key). Opt-in vault lock: `vault.protect(passphrase)` reseals
+under an Argon2id-derived key so a copied browser profile cannot use it; then
+load()/loadOrCreate()/save() throw PASSWORD_REQUIRED, `vault.unlock(passphrase)`
+returns the identity (STATELESS - hold it in memory; wrong passphrase =
+DECRYPT_FAILED), `vault.unprotect(passphrase)` restores device mode,
+`vault.isProtected()` discriminates, clear() is the lost-passphrase escape
+hatch (identity gone; re-import or re-invite).
+ONE admin signs the membership manifest: `signManifest(manifest, adminSigPriv)`.
+Attach with `attachTarget(target, { group: { identity, admin: pinnedAdminKey,
+manifest: signed } })` - the STORE verifies the manifest against the pinned
+admin key (TOFU from the invite; SIGNATURE_INVALID rejects before anything
+changes). Mutually exclusive with password; group stores never show `locked`.
+Copies are Ed25519-signed and sealed per member (fresh data key each publish);
+`state.peers[].author` = VERIFIED member id. `setGroup(nextSigned)` re-verifies
+(seq monotonic; older manifests throw MANIFEST_ROLLBACK; removal seals the
+future only). Codes: IDENTITY_REQUIRED, SIGNATURE_INVALID, NOT_A_RECIPIENT,
+MANIFEST_ROLLBACK. Needs WebCrypto Ed25519+X25519 (evergreen browsers, Node
+20+): check `await groupCryptoAvailable()`. Format: SPEC.md section 12.
+
+## Household sharing (mirror model), 'selfstore/households'
+
+Read-write sharing without re-keying anyone's backup: `createHouseholdGroup({
+store, kv, backend, storageKey? })`. The admin calls
+startShare() (refused on an encrypted store - the honest rule), publishes an
+invitation via the backend; a visitor opens it (openIncoming) and join()s:
+their own file stays theirs, a dedicated copy file mirrors it under K, and the
+others' copies attach as keyed peers - every converge folds them in. leave()
+is the one real revocation (admin: the invitation dies for everyone); data
+already converged stays in each member's own file. syncGroup() runs one fold
+round; restore() re-arms on boot. All network I/O goes through the
+ShareBackend port the host implements (an in-memory reference lives in the
+test suite). A store that becomes encrypted goes DORMANT (the mirror detaches)
+until the password is removed.
+
+## Multi-backup manager, 'selfstore/backups'
+
+`createBackupsManager({ store, kv, host, naming, keys? })`: the bookkeeping a
+backup panel needs. Naming: canonicalName ('App.zip') names the personal file;
+named ones derive as 'App (label).zip' (hooks override). The manager keeps the
+registry of connected files (self-healing, prune-on-gone), the per-file
+encrypted/shared memories (those bits live INSIDE the files, learned at
+open/create/probe), and the gestures: openBackup (two-step on an encrypted
+file), openPersonal (find-or-create), createNamed (starts BLANK), rename (id
+unchanged, safe on the active file), delete (active detaches first, local data
+stays), forgetShared. Invariants: fixed-id targets, the active id committed
+only AFTER a successful attach, wipe on every switch (no cross-file sync-meta).
+An own NAMED backup never reads as joined - ownership resolves against the
+destination listing. Failures are stable codes ('cancelled'|'gone'|'failed')
+in snapshot.lastError; hosts map them to copy and wrap subscribe in their own
+reactivity.
+
+## Per-collection sync config (same `sync` option on both stores)
+
+    sync: {
+      idField: 'id',                          // default id path (dot-notation ok)
+      ids: { events: 'ref' },                 // per-collection id path override
+      strategies: { accounts: 'lww-map' },    // per-collection strategy
+      fallback: 'lww-set'                     // for unlisted collections
+    }
+
+Strategies: 'lww-set' (default; later write per id wins, deletes tombstoned),
+'lww-map' (field-by-field; concurrent edits to DIFFERENT fields both survive),
+'grow-set' (append-only union, never conflicts), 'lww-register' (single value),
+'manual' (surface same-id concurrent edits instead of auto-resolving).
+
+## Error handling
+
+Every failure is a SelfstoreError with a stable `code`; ALWAYS branch on the
+code, never parse messages. Messages are developer-facing and often state the fix.
+BAD_FORMAT (not a backup / corrupt), UNSUPPORTED_VERSION (newer format
+generation, cipher, or KDF parameters out of the supported range),
+PASSWORD_REQUIRED (encrypted backup with no password given, or a
+passphrase-protected identity vault used without unlock()), DECRYPT_FAILED
+(wrong password/passphrase OR tampered bytes - indistinguishable by design),
+TOO_LARGE (zip-bomb guard: an entry over 512 MiB, or the archive total over
+1 GiB), AUTH_EXPIRED (genuine access loss, user gesture needed),
+TARGET_UNAVAILABLE (transient, auto-retried), TARGET_WRITE_FAILED (non-auth
+write failure), NOT_CONNECTED (no destination), UNEXPECTEDLY_UNENCRYPTED
+(downgrade guard), SCHEMA_TOO_NEW (data from a newer app schema; update the
+app). Helpers: isSelfstoreError(e) at the root; isAuthExpired(e) and
+AuthExpiredError in 'selfstore/advanced'. errorLabelKey(code) -> the stable
+i18n key ('error.authExpired'); show labelKey, log message. New codes may be
+added in minors - keep a default branch.
+
+## Facts and invariants
+
+- The backup file IS a valid ZIP in both modes. Unencrypted: meta.json +
+  selfstore.json (app collections) + files/* (+ sync.json when written by the
+  store). Encrypted: meta.json (cleartext params) + data.enc (the inner ZIP,
+  AES-GCM) + a readme.
+- The store's own bookkeeping (schema version + merge metadata) rides a dedicated
+  sync.json entry, so app collections stay pristine. Backups written by 0.0.x
+  (bookkeeping in a __store collection) still read.
+- Cosmetic header fields (app, appVersion, createdAt) are NOT authenticated;
+  never base security decisions on them. Crypto params and ciphertext are covered
+  by GCM authentication.
+- KDF defaults: Argon2id, 46 MiB memory, 3 passes; parameters are stored per file
+  (an old slot keeps its cost) and bounded on read (m<=1 GiB, t<=10, p<=4).
+- The KDF runs in a dedicated Web Worker when available (auto: spawned on
+  demand from dist/kdf-worker.js, idle-terminated; bundlers ship the asset via
+  the new Worker(new URL(...)) pattern) and falls back SILENTLY to the calling
+  thread with byte-identical results - no config, no API.
+- An empty/omitted password means "not encrypted". The library never phones home.
+- Multiple tabs of one app coordinate automatically (multiTab, default on in
+  browsers): each save folds the other tabs' writes, a cross-tab Web Lock
+  serializes them, a BroadcastChannel refreshes idle tabs live. Data only: a
+  durable target's connection stays per tab (restored at boot via restoreTarget).
+- Known limits: full-state sync per converge; deletion tombstones grow unless
+  compacted (opt in via tombstoneHorizonMs); binary files merge by id union (no
+  clocks). LWW keeps the later clock; the losing concurrent value is dropped
+  from data but surfaced in journal conflicts (both values, in memory; redacted
+  at rest).

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "selfstore",
+  "version": "1.0.0",
+  "description": "Local-first storage for browser apps: an IndexedDB working copy, portable encrypted ZIP backups (AES-256-GCM over Argon2id), durable homes (disk, Google Drive, WebDAV) and a serverless multi-device merge.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Florian Mousseau <florian.mousseau@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/selfstoredev/selfstore.git"
+  },
+  "homepage": "https://selfstore.dev",
+  "bugs": {
+    "url": "https://github.com/selfstoredev/selfstore/issues"
+  },
+  "keywords": [
+    "local-first",
+    "offline-first",
+    "indexeddb",
+    "encryption",
+    "backup",
+    "crdt",
+    "sync",
+    "typescript",
+    "browser-storage",
+    "e2e-encryption",
+    "zip",
+    "webdav",
+    "google-drive",
+    "argon2id",
+    "privacy"
+  ],
+  "sideEffects": [
+    "dist/kdf-worker.js"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./advanced": {
+      "types": "./dist/advanced.d.ts",
+      "import": "./dist/advanced.js"
+    },
+    "./backups": {
+      "types": "./dist/backups.d.ts",
+      "import": "./dist/backups.js"
+    },
+    "./flows": {
+      "types": "./dist/flows.d.ts",
+      "import": "./dist/flows.js"
+    },
+    "./groups": {
+      "types": "./dist/groups.d.ts",
+      "import": "./dist/groups.js"
+    },
+    "./households": {
+      "types": "./dist/households.d.ts",
+      "import": "./dist/households.js"
+    },
+    "./sync": {
+      "types": "./dist/sync.d.ts",
+      "import": "./dist/sync.js"
+    },
+    "./widgets": {
+      "types": "./dist/widgets.d.ts",
+      "import": "./dist/widgets.js"
+    },
+    "./kdf-worker": "./dist/kdf-worker.js"
+  },
+  "files": [
+    "dist",
+    "llms.txt"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit && tsc -p examples/tsconfig.json",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "fflate": "^0.8.3",
+    "hash-wasm": "4.12.0",
+    "idb": "^8.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "happy-dom": "^20.10.6",
+    "tsup": "^8.3.5",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}