@kubun/plugin-p2p 0.16.0 → 0.16.1

package/lib/context/group.js

@@ -536,6 +536,14 @@ export function createGroupContext(ctx, deps) {
         createCatalog: async (p)=>{
             const graphStore = await getGraphStore();
             const id = p.catalogID ?? deps.runtime.getRandomID();
+            // Idempotent when the caller pins the id: a crashed flow (e.g. a device
+            // join) recreates its own catalog deterministically on retry. `catalog:set`
+            // is replace-by-construction, so a re-create against an existing pinned id
+            // returns the stored catalog instead of failing a primary-key insert.
+            if (p.catalogID != null) {
+                const existing = await graphStore.getCatalog(id);
+                if (existing != null) return toCatalogData(existing);
+            }
             const hlcStr = HLC.serialize(deps.hlc.now());
             const filterCriteria = JSON.parse(p.filterCriteria);
             // Sign a self-contained `catalog:set` token at creation so the catalog can

package/lib/context/join.js

@@ -40,6 +40,33 @@ export function createJoinContext(ctx, deps) {
             const p2pStore = await getP2PStore(deps.stores);
             const stored = await p2pStore.getPendingJoinRequest(ctx.viewerDID);
             if (stored == null) {
+                // Idempotent by construction: completing a join is not atomic with the
+                // caller's own progress record (the offline exchange routinely spans two
+                // processes), so a caller that crashes after a successful completion
+                // retries with the same payload. A successful completion consumes the
+                // pending request at its end, so "no pending request" AND already an
+                // active member of the invited group means this exact join already
+                // landed — return it instead of failing. A fresh rejoin/re-admit always
+                // carries a new pending request (a new prepareJoinRequest), so it never
+                // takes this path; a genuinely bogus payload either fails to decode or
+                // leaves the device a non-member, so it still errors below.
+                let replayed;
+                try {
+                    replayed = decodeInvitePayload(invitePayloadStr);
+                } catch  {
+                    replayed = undefined;
+                }
+                if (replayed != null) {
+                    const existing = await p2pStore.getGroup(replayed.groupID);
+                    if (existing?.status === 'joined') {
+                        return await finalizeJoinedGroup({
+                            stores: deps.stores,
+                            emitter: deps.emitter,
+                            invite: replayed,
+                            logger: deps.logger
+                        });
+                    }
+                }
                 // Naming the way out matters: "no pending join request" reads to an
                 // operator as "the payload you were handed is bad", and they go asking
                 // for a new invite against key material that was never the problem.

package/lib/context/peer.js

@@ -80,8 +80,8 @@ import { toISO } from './types.js';
     // The version and variant nibbles are overwritten rather than derived, so the
     // string is a well-formed UUID that carries 122 bits of the digest.
     const bytes = Uint8Array.from(digest);
-    bytes[6] = bytes[6] & 0x0f | 0x40;
-    bytes[8] = bytes[8] & 0x3f | 0x80;
+    bytes[6] = (bytes[6] ?? 0) & 0x0f | 0x40;
+    bytes[8] = (bytes[8] ?? 0) & 0x3f | 0x80;
     const hex = Array.from(bytes, (b)=>b.toString(16).padStart(2, '0')).join('');
     return [
         hex.slice(0, 8),

package/lib/context/sync.js

@@ -132,7 +132,7 @@ export function createSyncContext(_ctx, deps) {
         const counts = await Promise.all(uniqueOwners.map((owner)=>store.listProvisioningExpectations({
                 ownerDID: owner
             })));
-        const withExpectation = uniqueOwners.filter((_owner, index)=>counts[index].length > 0);
+        const withExpectation = uniqueOwners.filter((_owner, index)=>(counts[index]?.length ?? 0) > 0);
         if (withExpectation.length === 0) {
             return [];
         }

package/lib/hub/hub-like.js

@@ -386,16 +386,18 @@ function rethrowHubError(error) {
             this.#logger?.debug('hub-like open reached no hub', {
                 topics: topics.length
             });
-            throw first.reason ?? new Error('hub did not answer any subscribe');
+            throw first?.reason ?? new Error('hub did not answer any subscribe');
         }
         this.#proven = true;
         const failed = [];
-        for(let i = 0; i < results.length; i++){
-            const result = results[i];
+        for (const [i, result] of results.entries()){
             if (result.status !== 'rejected') {
                 continue;
             }
             const topicID = topics[i];
+            if (topicID == null) {
+                continue;
+            }
             const error = asHubError(result.reason);
             this.#logger?.warn('hub-like re-subscribe failed', {
                 topicID,
@@ -444,10 +446,9 @@ function rethrowHubError(error) {
                     }
                 })));
             const stillFailing = [];
-            for(let i = 0; i < results.length; i++){
-                const result = results[i];
+            for (const [i, result] of results.entries()){
                 const topicID = pending[i];
-                if (result.status !== 'rejected') {
+                if (topicID == null || result.status !== 'rejected') {
                     continue;
                 }
                 if (isPermanentSubscribeFailure(asHubError(result.reason))) {

package/lib/schema.js

@@ -726,7 +726,7 @@ extend type Mutation {
   createGroup(input: CreateGroupInput!): CreateGroupPayload!
   requestCreateCircle(input: RequestCreateCircleInput!): RequestCreateCirclePayload!
   requestAddCircleMember(input: RequestAddCircleMemberInput!): RequestAddCircleMemberPayload!
-  createCatalog(name: String!, description: String, filterCriteria: String!): PeerCatalog!
+  createCatalog(catalogID: ID, name: String!, description: String, filterCriteria: String!): PeerCatalog!
   requestInviteToGroup(input: RequestInviteToGroupInput!): RequestInviteToGroupPayload!
   joinGroup(invitePayload: String!, joinRequestPayload: String!): JoinGroupPayload!
   prepareJoinRequest: PrepareJoinRequestPayload!
@@ -1101,6 +1101,7 @@ export function createP2PSchemaExtension(emitter, syncManager, logger = getKubun
                 },
                 createCatalog: async (_source, args, context)=>{
                     return await requireP2P(context).group.createCatalog({
+                        catalogID: args.catalogID,
                         name: args.name,
                         description: args.description,
                         filterCriteria: args.filterCriteria

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "license": "see LICENSE.md",
   "sideEffects": false,
   "type": "module",
@@ -91,8 +91,8 @@
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
-    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:js": "del 'lib/**/*.js' && swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "del 'lib/**/*.d.ts' 'lib/**/*.d.ts.map' && tsc --emitDeclarationOnly --skipLibCheck",
     "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
     "test:unit": "vitest run"