@kubun/plugin-p2p 0.17.0 → 0.17.1

package/lib/schema.js

@@ -114,6 +114,11 @@ const CONTROL_REQUEST_KIND_TO_SDL = {
     invite: 'INVITE',
     remove: 'REMOVE'
 };
+// Internal lowercase record-provisioning outcome -> SDL enum name.
+const RECORD_PROVISIONING_STATUS_TO_SDL = {
+    recorded: 'RECORDED',
+    retry: 'RETRY'
+};
 /** Project a control request into its SDL shape, mapping both enums to uppercase. */ function toControlRequestSDL(request) {
     return {
         ...request,
@@ -692,6 +697,33 @@ type CredentialProvisioningStatus {
   reason: String
 }
 
+type BeginProvisioningExpectationPayload {
+  """
+  Freshly minted attempt id; pass it to recordProvisioningExpectation /
+  abandonProvisioningExpectation to close this attempt.
+  """
+  attemptId: ID!
+}
+
+enum RecordProvisioningExpectationStatus {
+  """The attempt's epoch bound the provisioning floor for this owner/grantor."""
+  RECORDED
+  """
+  A higher manifest already landed; the floor was not lowered. Re-run the grant
+  with minEpoch, then record the new attempt.
+  """
+  RETRY
+}
+
+type RecordProvisioningExpectationPayload {
+  status: RecordProvisioningExpectationStatus!
+  """
+  Present only on RETRY: the recipient's now-held epoch. Re-run the grant with
+  this as the new minEpoch.
+  """
+  minEpoch: Int
+}
+
 extend type Mutation {
   connectPeer(url: String!): ConnectPeerPayload!
   sharePeerGroup(peerDID: ID!, groupID: ID, name: String, send: ShareInput, receive: ShareReceiveInput): SharePeerGroupPayload!
@@ -711,6 +743,27 @@ extend type Mutation {
   reprovision attempt always supersedes a manifest it already holds. Defaults to 0.
   """
   grantDeviceCredentials(groupID: ID!, recipientDID: DID!, ownerDID: DID!, minEpoch: Int): GrantDeviceCredentialsPayload!
+  """
+  Arm this device to converge a credential grant for ownerDID from grantorDID:
+  write the provisioning-expectation row that lets the credential-reconcile PULL
+  fetch that owner's buckets (a delegate-signed grant converges only via the
+  pull, never the live apply). Call before asking the grantor to grant, then
+  recordProvisioningExpectation once the grant returns its epoch. Mirrors the
+  credentialProvisioningStatus query's recipient-local surface.
+  """
+  beginProvisioningExpectation(ownerDID: DID!, grantorDID: DID!): BeginProvisioningExpectationPayload!
+  """
+  Bind the provisioning floor for an in-flight attempt to the epoch its grant was
+  signed under. Returns RECORDED when the floor binds, or RETRY with the held
+  epoch when a higher manifest already landed (re-grant with minEpoch, then record
+  the new attempt).
+  """
+  recordProvisioningExpectation(ownerDID: DID!, grantorDID: DID!, attemptId: ID!, epoch: Int!): RecordProvisioningExpectationPayload!
+  """
+  Stop tracking one provisioning attempt. Removes only this attemptId; never binds
+  or lowers a floor. Returns true.
+  """
+  abandonProvisioningExpectation(ownerDID: DID!, grantorDID: DID!, attemptId: ID!): Boolean!
   joinPeerGroup(peerDID: ID!, groupID: ID!): JoinPeerGroupPayload!
   """
   Apply one circle's desired sync end state. A null argument leaves that dimension
@@ -1043,6 +1096,32 @@ export function createP2PSchemaExtension(emitter, syncManager, logger = getKubun
                         epoch
                     };
                 },
+                beginProvisioningExpectation: async (_source, args, context)=>{
+                    return await requireP2P(context).peer.beginProvisioningExpectation({
+                        ownerDID: args.ownerDID,
+                        grantorDID: args.grantorDID
+                    });
+                },
+                recordProvisioningExpectation: async (_source, args, context)=>{
+                    const result = await requireP2P(context).peer.recordProvisioningExpectation({
+                        ownerDID: args.ownerDID,
+                        grantorDID: args.grantorDID,
+                        attemptId: args.attemptId,
+                        epoch: args.epoch
+                    });
+                    return {
+                        status: RECORD_PROVISIONING_STATUS_TO_SDL[result.status],
+                        minEpoch: result.status === 'retry' ? result.minEpoch : null
+                    };
+                },
+                abandonProvisioningExpectation: async (_source, args, context)=>{
+                    await requireP2P(context).peer.abandonProvisioningExpectation({
+                        ownerDID: args.ownerDID,
+                        grantorDID: args.grantorDID,
+                        attemptId: args.attemptId
+                    });
+                    return true;
+                },
                 joinPeerGroup: async (_source, args, context)=>{
                     return await requireP2P(context).peer.joinPeerGroup({
                         peerDID: args.peerDID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "license": "see LICENSE.md",
   "sideEffects": false,
   "type": "module",
@@ -74,7 +74,7 @@
     "@kubun/db-postgres": "^0.17.0",
     "@kubun/hub": "^0.17.0",
     "@kubun/plugin-blob": "^0.17.0",
-    "@kubun/plugin-connector": "^0.17.0",
+    "@kubun/plugin-connector": "^0.17.1",
     "@kubun/plugin-service-server": "^0.17.0",
     "@kubun/plugin-workflow": "^0.17.0",
     "@kubun/service-graph-api": "^0.17.0",