wireweave 0.3.21 → 0.3.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wireweave",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "nostr + webrtc voice + data SDK. networking layer for 247420 projects.",
   "type": "module",
   "main": "./src/index.js",

package/src/bans.js

@@ -6,10 +6,11 @@ export class Bans extends EventTarget {
     if (!relayPool) throw new Error('Bans: relayPool required');
     this.pool = relayPool; this.auth = auth; this.roles = roles;
     this.store = new Map();
-    this.sub = null;
+    this.subs = new Map();
   }
 
   isBanned(serverId, pubkey) { return !!(this.store.get(serverId)?.banned || []).includes(pubkey); }
+  isKicked(serverId, pubkey) { return !!(this.store.get(serverId)?.kicked || []).includes(pubkey); }
 
   isTimedOut(serverId, pubkey) {
     const t = this.store.get(serverId)?.timeouts?.[pubkey];
@@ -51,12 +52,13 @@ export class Bans extends EventTarget {
   }
 
   subscribe(serverId) {
-    if (this.sub) { this.pool.unsubscribe(this.sub); this.sub = null; }
+    if (this.subs.has(serverId)) return;
     if (!serverId) return;
     const creator = serverId.split(':')[0];
     if (!creator) return;
-    this.sub = 'bans-' + serverId;
-    this.pool.subscribe(this.sub,
+    const subId = 'bans-' + serverId;
+    this.subs.set(serverId, subId);
+    this.pool.subscribe(subId,
       [{ kinds: [30078], authors: [creator], '#server': [serverId] }],
       (event) => {
         if (event.pubkey !== creator) return;
@@ -64,11 +66,14 @@ export class Bans extends EventTarget {
           const dTag = event.tags.find(t => t[0] === 'd');
           if (!dTag?.[1]) return;
           const parsed = parseDtag(dTag[1]);
-          if (!parsed || (parsed.ns !== 'ban' && parsed.ns !== 'timeout')) return;
+          if (!parsed || !['ban', 'timeout', 'kick'].includes(parsed.ns)) return;
           const pubkey = parsed.parts[parsed.parts.length - 1];
-          const data = this.store.get(serverId) || { banned: [], timeouts: {} };
+          const data = this.store.get(serverId) || { banned: [], timeouts: {}, kicked: [] };
           if (parsed.ns === 'ban' && pubkey && !data.banned.includes(pubkey)) data.banned.push(pubkey);
-          else if (parsed.ns === 'timeout' && pubkey) {
+          else if (parsed.ns === 'kick' && pubkey) {
+            data.kicked = data.kicked || [];
+            if (!data.kicked.includes(pubkey)) data.kicked.push(pubkey);
+          } else if (parsed.ns === 'timeout' && pubkey) {
             const body = JSON.parse(event.content);
             if (body.expiry > Math.floor(Date.now() / 1000)) (data.timeouts = data.timeouts || {})[pubkey] = { expiry: body.expiry };
             else if (data.timeouts?.[pubkey]) delete data.timeouts[pubkey];
@@ -78,6 +83,11 @@ export class Bans extends EventTarget {
         } catch {}
       });
   }
+
+  unsubscribe(serverId) {
+    const subId = this.subs.get(serverId);
+    if (subId) { this.pool.unsubscribe(subId); this.subs.delete(serverId); }
+  }
 }
 
 export const createBans = (opts) => new Bans(opts);

package/src/channels.js

@@ -19,9 +19,10 @@ export class Channels extends EventTarget {
     this.serverId = ''; this.channels = []; this.categories = [];
   }
 
-  isOwner() { return this.auth.pubkey && this.serverId && this.auth.pubkey === this.serverId.split(':')[0]; }
+  isOwner() { return !!(this.auth.pubkey && this.serverId && this.auth.pubkey === this.serverId.split(':')[0]); }
 
   load(serverId, onReady) {
+    if (this.serverId) this.pool.unsubscribe('channels-' + this.serverId);
     this.serverId = serverId;
     this.channels = []; this.categories = [];
     const ownerPubkey = serverId.split(':')[0];
@@ -62,12 +63,14 @@ export class Channels extends EventTarget {
   }
 
   async create(name, type = 'text', categoryId = 'general') {
-    this.channels = [...this.channels, { id: 'ch-' + Date.now(), name, type, categoryId, position: this.channels.length }];
+    if (!this.isOwner()) throw new Error('owner only');
+    this.channels = [...this.channels, { id: 'ch-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6), name, type, categoryId, position: this.channels.length }];
     await this._publish();
     this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async rename(id, name) {
+    if (!this.isOwner()) throw new Error('owner only');
     this.channels = this.channels.map(c => c.id === id ? { ...c, name } : c);
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
@@ -75,38 +78,45 @@ export class Channels extends EventTarget {
   // Per-channel metadata patch — used for topic, voiceMode, and any future
   // server-published channel-scoped configuration. Owner-only.
   async update(id, patch) {
+    if (!this.isOwner()) throw new Error('owner only');
     if (!patch || typeof patch !== 'object') return;
     this.channels = this.channels.map(c => c.id === id ? { ...c, ...patch } : c);
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async remove(id) {
+    if (!this.isOwner()) throw new Error('owner only');
     this.channels = this.channels.filter(c => c.id !== id);
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async createCategory(name) {
-    this.categories = [...this.categories, { id: 'cat-' + Date.now(), name, position: this.categories.length }];
+    if (!this.isOwner()) throw new Error('owner only');
+    this.categories = [...this.categories, { id: 'cat-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6), name, position: this.categories.length }];
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async renameCategory(id, name) {
+    if (!this.isOwner()) throw new Error('owner only');
     this.categories = this.categories.map(c => c.id === id ? { ...c, name } : c);
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async deleteCategory(id) {
+    if (!this.isOwner()) throw new Error('owner only');
     this.categories = this.categories.filter(c => c.id !== id);
     this.channels = this.channels.map(c => c.categoryId === id ? { ...c, categoryId: null } : c);
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async reorder(catId, ids) {
+    if (!this.isOwner()) throw new Error('owner only');
     ids.forEach((chId, idx) => { this.channels = this.channels.map(c => c.id === chId ? { ...c, position: idx, categoryId: catId } : c); });
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }
 
   async reorderCategories(ids) {
+    if (!this.isOwner()) throw new Error('owner only');
     ids.forEach((catId, idx) => { this.categories = this.categories.map(c => c.id === catId ? { ...c, position: idx } : c); });
     await this._publish(); this._emit('updated', { channels: this.channels, categories: this.categories });
   }

package/src/chat.js

@@ -52,6 +52,11 @@ export class Chat extends EventTarget {
   }
 
   async deleteMessage(id) {
+    const msg = this.messages.find(m => m.id === id);
+    if (!msg) return;
+    const { serverId } = this.getChannelContext();
+    const isAuthor = msg.userId === this.auth.pubkey;
+    if (!isAuthor && !this.isAdmin(serverId)) throw new Error('Cannot delete: not author or admin');
     const signed = await this.auth.sign({ kind: 5, created_at: Math.floor(Date.now() / 1000), tags: [['e', id]], content: 'deleted' });
     this.pool.publish(signed);
     this.messages = this.messages.filter(m => m.id !== id);

package/src/data.js

@@ -34,7 +34,8 @@ export class DataSession extends EventTarget {
   }
 
   _initActor() {
-    const machine = this.fsm.dataMachine || this.fsm.voiceMachine;
+    const machine = this.fsm.dataMachine;
+    if (!machine) throw new Error('DataSession: fsm.dataMachine missing');
     this.actor = this.xstate.createActor(machine);
     this.actor.subscribe((snap) => this.dispatchEvent(new CustomEvent('state', { detail: { value: snap.value } })));
     this.actor.start();

package/src/message.js

@@ -10,7 +10,7 @@ export class MessageBus extends EventTarget {
   register(type, fn) { this.handlers[type] = fn; }
 
   add(text, { audioData = null, userId = null, username = null } = {}) {
-    const msg = { id: Date.now() + Math.random(), text, time: Date.now(), userId, username, audioData };
+    const msg = { id: Date.now().toString(36) + Math.random().toString(36).slice(2), text, time: Date.now(), userId, username, audioData };
     this.messages = [...this.messages, msg];
     if (this.messages.length > this.max) this.messages = this.messages.slice(-this.max);
     this.dispatchEvent(new CustomEvent('message', { detail: msg }));

package/src/roles.js

@@ -6,7 +6,7 @@ export class Roles extends EventTarget {
     if (!relayPool || !auth) throw new Error('Roles: deps required');
     this.pool = relayPool; this.auth = auth;
     this.store = new Map();
-    this.sub = null;
+    this.subs = new Map();
   }
 
   _creatorOf(serverId) { return serverId ? serverId.split(':')[0] : null; }
@@ -39,12 +39,13 @@ export class Roles extends EventTarget {
   }
 
   subscribe(serverId) {
-    if (this.sub) { this.pool.unsubscribe(this.sub); this.sub = null; }
+    if (this.subs.has(serverId)) return;
     if (!serverId) return;
     const creator = this._creatorOf(serverId);
     if (!creator) return;
-    this.sub = 'roles-' + serverId;
-    this.pool.subscribe(this.sub,
+    const subId = 'roles-' + serverId;
+    this.subs.set(serverId, subId);
+    this.pool.subscribe(subId,
       [{ kinds: [30078], authors: [creator], '#d': [dtag('roles', serverId)] }],
       (event) => {
         if (event.pubkey !== creator) return;
@@ -55,6 +56,11 @@ export class Roles extends EventTarget {
         } catch {}
       });
   }
+
+  unsubscribe(serverId) {
+    const subId = this.subs.get(serverId);
+    if (subId) { this.pool.unsubscribe(subId); this.subs.delete(serverId); }
+  }
 }
 
 export const createRoles = (opts) => new Roles(opts);

package/src/settings.js

@@ -9,7 +9,7 @@ export class Settings extends EventTarget {
     if (!relayPool || !auth || !roles) throw new Error('Settings: deps required');
     this.pool = relayPool; this.auth = auth; this.roles = roles;
     this.store = new Map();
-    this.sub = null;
+    this.subs = new Map();
   }
 
   getBitrate(serverId) { return this.store.get(serverId)?.opusBitrate || 24000; }
@@ -57,18 +57,24 @@ export class Settings extends EventTarget {
   }
 
   subscribe(serverId) {
-    if (this.sub) { this.pool.unsubscribe(this.sub); this.sub = null; }
+    if (this.subs.has(serverId)) return;
     if (!serverId) return;
     const creator = serverId.split(':')[0];
     if (!creator) return;
-    this.sub = 'settings-' + serverId;
-    this.pool.subscribe(this.sub,
+    const subId = 'settings-' + serverId;
+    this.subs.set(serverId, subId);
+    this.pool.subscribe(subId,
       [{ kinds: [30078], authors: [creator], '#d': [dtag('settings', serverId)] }],
       (event) => {
         if (event.pubkey !== creator) return;
         try { this.store.set(serverId, JSON.parse(event.content)); this.dispatchEvent(new CustomEvent('updated', { detail: { serverId, next: this.store.get(serverId) } })); } catch {}
       });
   }
+
+  unsubscribe(serverId) {
+    const subId = this.subs.get(serverId);
+    if (subId) { this.pool.unsubscribe(subId); this.subs.delete(serverId); }
+  }
 }
 
 export const createSettings = (opts) => new Settings(opts);

package/src/wireweave.js

@@ -12,6 +12,7 @@ import { createSettings } from './settings.js';
 import { createMedia } from './media.js';
 import { createPages } from './pages.js';
 import { createDM } from './dm.js';
+import { createDataSession } from './data.js';
 import { register } from './debug.js';
 
 export const createWireweave = ({
@@ -86,12 +87,24 @@ export const createWireweave = ({
     return dm;
   };
 
+  // DataSession is lazy for the same reason as DM: requires xstate and FSM.
+  // onSwitch accumulates subscriptions across all visited servers (idempotent
+  // Map pattern) — no unsubscribe on server switch by design so offline data
+  // from prior servers remains cached.
+  let data = null;
+  const ensureData = ({ room = '', displayName = 'Guest', namespace = '' } = {}) => {
+    if (!data) data = createDataSession({ fsm, xstate, relayPool: pool, auth, namespace });
+    return data;
+  };
+
   const api = {
     pool, auth, fsm, message, bans, roles, settings, pages, media, channels, servers, chat,
     get voice() { return voice; },
     ensureVoice,
     get dm() { return dm; },
     ensureDM,
+    get data() { return data; },
+    ensureData,
     setCurrentChannel,
     get currentChannelId() { return currentChannelId; },
     get currentServerId() { return servers.currentServerId; }