@metalabel/dfos-web-relay 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -168,6 +168,24 @@ interface RelayStore {
     getPeerCursor(peerUrl: string): Promise<string | undefined>;
     /** Update last-synced log cursor for a peer relay */
     setPeerCursor(peerUrl: string, cursor: string): Promise<void>;
+    /** Store a raw JWS token by CID — idempotent, ignores duplicates */
+    putRawOp(cid: string, jwsToken: string): Promise<void>;
+    /** Return JWS tokens for unsequenced (pending) ops */
+    getUnsequencedOps(limit: number): Promise<string[]>;
+    /** Mark ops as successfully sequenced */
+    markOpsSequenced(cids: string[]): Promise<void>;
+    /** Mark an op as permanently rejected */
+    markOpRejected(cid: string, reason: string): Promise<void>;
+    /** Count of pending (unsequenced) raw ops */
+    countUnsequenced(): Promise<number>;
+    /** Reset all non-rejected raw ops to pending (re-sequence) */
+    resetSequencer(): Promise<void>;
+}
+/** Result of a sequencer run */
+interface SequenceResult {
+    sequenced: number;
+    rejected: number;
+    pending: number;
 }
 interface IngestionResult {
     cid: string;
@@ -261,6 +279,13 @@ declare class MemoryRelayStore implements RelayStore {
     } | null>;
     getPeerCursor(peerUrl: string): Promise<string | undefined>;
     setPeerCursor(peerUrl: string, cursor: string): Promise<void>;
+    private rawOps;
+    putRawOp(cid: string, jwsToken: string): Promise<void>;
+    getUnsequencedOps(limit: number): Promise<string[]>;
+    markOpsSequenced(cids: string[]): Promise<void>;
+    markOpRejected(cid: string, _reason: string): Promise<void>;
+    countUnsequenced(): Promise<number>;
+    resetSequencer(): Promise<void>;
 }
 
 /**
@@ -297,4 +322,21 @@ declare const ingestOperations: (tokens: string[], store: RelayStore, options?:
     logEnabled?: boolean;
 }) => Promise<IngestionResult[]>;
 
-export { type BlobKey, type CreatedRelay, type IngestionResult, type LogEntry, MemoryRelayStore, type OperationKind, type PeerClient, type PeerConfig, type PeerLogEntry, type RelayIdentity, type RelayOptions, type RelayStore, type StoredBeacon, type StoredContentChain, type StoredIdentityChain, type StoredOperation, bootstrapRelayIdentity, createCurrentKeyResolver, createHttpPeerClient, createKeyResolver, createRelay, ingestOperations };
+/**
+ * Returns true if the rejection is due to a missing dependency that may
+ * arrive later via sync or gossip. Only these specific patterns are
+ * retryable — everything else is treated as permanent.
+ */
+declare const isDependencyFailure: (error: string) => boolean;
+/** Derive the operation CID from a JWS token */
+declare const computeOpCID: (jwsToken: string) => Promise<string | undefined>;
+/**
+ * Process unsequenced raw ops in a fixed-point loop until no more progress
+ * is made. Returns the JWS tokens of newly sequenced ops and aggregate stats.
+ */
+declare const sequenceOps: (store: RelayStore) => Promise<{
+    newOps: string[];
+    result: SequenceResult;
+}>;
+
+export { type BlobKey, type CreatedRelay, type IngestionResult, type LogEntry, MemoryRelayStore, type OperationKind, type PeerClient, type PeerConfig, type PeerLogEntry, type RelayIdentity, type RelayOptions, type RelayStore, type SequenceResult, type StoredBeacon, type StoredContentChain, type StoredIdentityChain, type StoredOperation, bootstrapRelayIdentity, computeOpCID, createCurrentKeyResolver, createHttpPeerClient, createKeyResolver, createRelay, ingestOperations, isDependencyFailure, sequenceOps };

package/dist/index.js

@@ -723,7 +723,7 @@ var createHttpPeerClient = () => {
 
 // src/relay.ts
 import { VC_TYPE_CONTENT_READ, verifyCredential } from "@metalabel/dfos-protocol/credentials";
-import { dagCborCanonicalEncode as dagCborCanonicalEncode2, decodeJwsUnsafe as decodeJwsUnsafe3 } from "@metalabel/dfos-protocol/crypto";
+import { dagCborCanonicalEncode as dagCborCanonicalEncode3, decodeJwsUnsafe as decodeJwsUnsafe4 } from "@metalabel/dfos-protocol/crypto";
 import { Hono } from "hono";
 import { z } from "zod";
 
@@ -753,6 +753,59 @@ var authenticateRequest = async (authHeader, relayDID, store) => {
   }
 };
 
+// src/sequencer.ts
+import { dagCborCanonicalEncode as dagCborCanonicalEncode2, decodeJwsUnsafe as decodeJwsUnsafe3 } from "@metalabel/dfos-protocol/crypto";
+var isDependencyFailure = (error) => {
+  const patterns = [
+    "unknown previous operation",
+    "unknown identity:",
+    "content chain not found:",
+    "failed to compute state at fork point:"
+  ];
+  return patterns.some((p) => error.includes(p));
+};
+var computeOpCID = async (jwsToken) => {
+  const decoded = decodeJwsUnsafe3(jwsToken);
+  if (!decoded) return void 0;
+  const encoded = await dagCborCanonicalEncode2(decoded.payload);
+  return encoded.cid.toString();
+};
+var sequenceOps = async (store) => {
+  const newOps = [];
+  const result = { sequenced: 0, rejected: 0, pending: 0 };
+  for (; ; ) {
+    const tokens = await store.getUnsequencedOps(1e4);
+    if (tokens.length === 0) break;
+    const results = await ingestOperations(tokens, store);
+    let progress = false;
+    const sequencedCIDs = [];
+    for (let i = 0; i < results.length; i++) {
+      const res = results[i];
+      if (!res.cid) continue;
+      if (res.status === "new") {
+        sequencedCIDs.push(res.cid);
+        newOps.push(tokens[i]);
+        result.sequenced++;
+        progress = true;
+      } else if (res.status === "duplicate") {
+        sequencedCIDs.push(res.cid);
+        progress = true;
+      } else if (res.status === "rejected" && !isDependencyFailure(res.error ?? "")) {
+        await store.markOpRejected(res.cid, res.error ?? "unknown");
+        result.rejected++;
+        progress = true;
+      } else {
+        result.pending++;
+      }
+    }
+    if (sequencedCIDs.length > 0) {
+      await store.markOpsSequenced(sequencedCIDs);
+    }
+    if (!progress) break;
+  }
+  return { newOps, result };
+};
+
 // src/relay.ts
 var IngestBody = z.object({
   operations: z.array(z.string()).min(1).max(100)
@@ -769,20 +822,33 @@ var createRelay = async (options) => {
   const identity = options.identity ?? await bootstrapRelayIdentity(store);
   const relayDID = identity.did;
   const profileArtifactJws = identity.profileArtifactJws;
+  const gossip = (ops) => {
+    if (ops.length === 0 || gossipPeers.length === 0 || !peerClient) return;
+    for (const peer of gossipPeers) {
+      peerClient.submitOperations(peer.url, ops).catch(() => {
+      });
+    }
+  };
   const ingestWithGossip = async (tokens) => {
+    for (const token of tokens) {
+      const cid = await computeOpCID(token);
+      if (cid) await store.putRawOp(cid, token);
+    }
     const results = await ingestOperations(tokens, store, { logEnabled });
-    if (gossipPeers.length > 0 && peerClient) {
-      const newOps = [];
-      for (let i = 0; i < results.length; i++) {
-        if (results[i].status === "new") newOps.push(tokens[i]);
-      }
-      if (newOps.length > 0) {
-        for (const peer of gossipPeers) {
-          peerClient.submitOperations(peer.url, newOps).catch(() => {
-          });
-        }
+    const newOps = [];
+    for (let i = 0; i < results.length; i++) {
+      const res = results[i];
+      if (!res.cid) continue;
+      if (res.status === "new") {
+        await store.markOpsSequenced([res.cid]);
+        newOps.push(tokens[i]);
+      } else if (res.status === "duplicate") {
+        await store.markOpsSequenced([res.cid]);
       }
     }
+    const { newOps: seqNewOps } = await sequenceOps(store);
+    gossip(newOps);
+    gossip(seqNewOps);
     return results;
   };
   const app = new Hono();
@@ -829,7 +895,7 @@ var createRelay = async (options) => {
     const after = c.req.query("after");
     const limit = Math.min(Number(c.req.query("limit") || 100), 1e3);
     const entries = chain.log.map((jws) => {
-      const decoded = decodeJwsUnsafe3(jws);
+      const decoded = decodeJwsUnsafe4(jws);
       return { cid: decoded?.header.cid || "", jwsToken: jws };
     });
     let startIdx = 0;
@@ -875,7 +941,7 @@ var createRelay = async (options) => {
     const after = c.req.query("after");
     const limit = Math.min(Number(c.req.query("limit") || 100), 1e3);
     const entries = chain.log.map((jws) => {
-      const decoded = decodeJwsUnsafe3(jws);
+      const decoded = decodeJwsUnsafe4(jws);
       return { cid: decoded?.header.cid || "", jwsToken: jws };
     });
     let startIdx = 0;
@@ -962,7 +1028,7 @@ var createRelay = async (options) => {
     let documentCID = null;
     let operationSignerDID = null;
     for (const token of chain.log) {
-      const decoded = decodeJwsUnsafe3(token);
+      const decoded = decodeJwsUnsafe4(token);
       if (!decoded) continue;
       if (decoded.header.cid !== operationCID) continue;
       const payload = decoded.payload;
@@ -979,7 +1045,7 @@ var createRelay = async (options) => {
     const bytes = new Uint8Array(await c.req.arrayBuffer());
     try {
       const parsed = JSON.parse(new TextDecoder().decode(bytes));
-      const encoded = await dagCborCanonicalEncode2(parsed);
+      const encoded = await dagCborCanonicalEncode3(parsed);
       if (encoded.cid.toString() !== documentCID) {
         return c.json({ error: "blob bytes do not match documentCID" }, 400);
       }
@@ -1048,7 +1114,7 @@ var readBlob = async (params) => {
     documentCID = chain.state.currentDocumentCID;
   } else {
     for (const token of chain.log) {
-      const decoded = decodeJwsUnsafe3(token);
+      const decoded = decodeJwsUnsafe4(token);
       if (!decoded) continue;
       if (decoded.header.cid === ref) {
         operationFound = true;
@@ -1076,7 +1142,7 @@ var verifyReadCredential = async (auth, chain, contentId, credHeader, store) =>
   }
   const resolveKey = createCurrentKeyResolver(store);
   try {
-    const vcDecoded = decodeJwsUnsafe3(credHeader);
+    const vcDecoded = decodeJwsUnsafe4(credHeader);
     if (!vcDecoded) throw new Error("invalid credential format");
     const vcHeader = vcDecoded.header;
     if (!vcHeader.kid) throw new Error("credential missing kid");
@@ -1112,7 +1178,7 @@ var verifyReadCredential = async (auth, chain, contentId, credHeader, store) =>
 
 // src/store.ts
 import { verifyContentChain as verifyContentChain2, verifyIdentityChain as verifyIdentityChain2 } from "@metalabel/dfos-protocol/chain";
-import { decodeJwsUnsafe as decodeJwsUnsafe4 } from "@metalabel/dfos-protocol/crypto";
+import { decodeJwsUnsafe as decodeJwsUnsafe5 } from "@metalabel/dfos-protocol/crypto";
 var blobKeyString = (key) => `${key.creatorDID}::${key.documentCID}`;
 var MemoryRelayStore = class {
   operations = /* @__PURE__ */ new Map();
@@ -1158,12 +1224,12 @@ var MemoryRelayStore = class {
   }
   async addCountersignature(operationCID, jwsToken) {
     const existing = this.countersignatures.get(operationCID) ?? [];
-    const decoded = decodeJwsUnsafe4(jwsToken);
+    const decoded = decodeJwsUnsafe5(jwsToken);
     if (decoded) {
       const kid = decoded.header.kid;
       const witnessDID = kid.includes("#") ? kid.split("#")[0] : kid;
       for (const cs of existing) {
-        const d = decodeJwsUnsafe4(cs);
+        const d = decodeJwsUnsafe5(cs);
         if (!d) continue;
         const existingKid = d.header.kid;
         const existingDID = existingKid.includes("#") ? existingKid.split("#")[0] : existingKid;
@@ -1192,7 +1258,7 @@ var MemoryRelayStore = class {
     if (!chain) return null;
     const opsByCID = /* @__PURE__ */ new Map();
     for (const jws of chain.log) {
-      const decoded = decodeJwsUnsafe4(jws);
+      const decoded = decodeJwsUnsafe5(jws);
       if (!decoded) continue;
       const payload = decoded.payload;
       const opCID = typeof decoded.header.cid === "string" ? decoded.header.cid : "";
@@ -1209,7 +1275,7 @@ var MemoryRelayStore = class {
       currentCID = op.previousCID;
     }
     const identity = await verifyIdentityChain2({ didPrefix: "did:dfos", log: path });
-    const targetDecoded = decodeJwsUnsafe4(opsByCID.get(cid).jws);
+    const targetDecoded = decodeJwsUnsafe5(opsByCID.get(cid).jws);
     const lastCreatedAt = typeof targetDecoded?.payload?.["createdAt"] === "string" ? (targetDecoded?.payload)["createdAt"] : "";
     return { state: identity, lastCreatedAt };
   }
@@ -1218,7 +1284,7 @@ var MemoryRelayStore = class {
     if (!chain) return null;
     const opsByCID = /* @__PURE__ */ new Map();
     for (const jws of chain.log) {
-      const decoded = decodeJwsUnsafe4(jws);
+      const decoded = decodeJwsUnsafe5(jws);
       if (!decoded) continue;
       const payload = decoded.payload;
       const opCID = typeof decoded.header.cid === "string" ? decoded.header.cid : "";
@@ -1236,7 +1302,7 @@ var MemoryRelayStore = class {
     }
     const resolveKey = createKeyResolver(this);
     const content = await verifyContentChain2({ log: path, resolveKey, enforceAuthorization: true });
-    const targetDecoded = decodeJwsUnsafe4(opsByCID.get(cid).jws);
+    const targetDecoded = decodeJwsUnsafe5(opsByCID.get(cid).jws);
     const lastCreatedAt = typeof targetDecoded?.payload?.["createdAt"] === "string" ? (targetDecoded?.payload)["createdAt"] : "";
     return { state: content, lastCreatedAt };
   }
@@ -1246,13 +1312,55 @@ var MemoryRelayStore = class {
   async setPeerCursor(peerUrl, cursor) {
     this.peerCursors.set(peerUrl, cursor);
   }
+  // --- raw ops ---
+  rawOps = /* @__PURE__ */ new Map();
+  async putRawOp(cid, jwsToken) {
+    if (!this.rawOps.has(cid)) {
+      this.rawOps.set(cid, { jwsToken, status: "pending" });
+    }
+  }
+  async getUnsequencedOps(limit) {
+    const out = [];
+    for (const entry of this.rawOps.values()) {
+      if (entry.status === "pending") {
+        out.push(entry.jwsToken);
+        if (out.length >= limit) break;
+      }
+    }
+    return out;
+  }
+  async markOpsSequenced(cids) {
+    for (const cid of cids) {
+      const entry = this.rawOps.get(cid);
+      if (entry) entry.status = "sequenced";
+    }
+  }
+  async markOpRejected(cid, _reason) {
+    const entry = this.rawOps.get(cid);
+    if (entry) entry.status = "rejected";
+  }
+  async countUnsequenced() {
+    let count = 0;
+    for (const entry of this.rawOps.values()) {
+      if (entry.status === "pending") count++;
+    }
+    return count;
+  }
+  async resetSequencer() {
+    for (const entry of this.rawOps.values()) {
+      if (entry.status !== "rejected") entry.status = "pending";
+    }
+  }
 };
 export {
   MemoryRelayStore,
   bootstrapRelayIdentity,
+  computeOpCID,
   createCurrentKeyResolver,
   createHttpPeerClient,
   createKeyResolver,
   createRelay,
-  ingestOperations
+  ingestOperations,
+  isDependencyFailure,
+  sequenceOps
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metalabel/dfos-web-relay",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "DFOS Web Relay — verifying HTTP relay for identity chains, content chains, beacons, and content blobs",
   "license": "MIT",
@@ -52,7 +52,7 @@
     "tsup": "^8.5.1",
     "tsx": "^4.20.3",
     "vitest": "^4.1.0",
-    "@metalabel/dfos-protocol": "0.6.0"
+    "@metalabel/dfos-protocol": "0.7.0"
   },
   "scripts": {
     "build": "tsup",